public void Validate_DoesNotUseOverridden_GetHashCodeOrEquals()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
DefaultBodyModelValidator validator = new DefaultBodyModelValidator();
object instance = new[]
{
new TypeThatOverridesEquals {
Funny = "hehe"
},
new TypeThatOverridesEquals {
Funny = "hehe"
}
};
// Act & Assert
Assert.DoesNotThrow(
() =>
validator.Validate(
instance,
typeof(TypeThatOverridesEquals[]),
metadataProvider,
actionContext,
String.Empty
)
);
}
public void GetModelBindingContext_UsesBindAttributeOnType_IfNoBindAttributeOnParameter_ForPrefix()
{
// Arrange
var type = typeof(ControllerActionArgumentBinderTests);
var methodInfo = type.GetMethod("ParameterWithNoBindAttribute");
var actionContext = new ActionContext(new RouteContext(Mock.Of <HttpContext>()),
Mock.Of <ActionDescriptor>());
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var modelMetadata = metadataProvider.GetMetadataForParameter(modelAccessor: null,
methodInfo: methodInfo,
parameterName: "parameter");
var actionBindingContext = new ActionBindingContext(actionContext,
Mock.Of <IModelMetadataProvider>(),
Mock.Of <IModelBinder>(),
Mock.Of <IValueProvider>(),
Mock.Of <IInputFormatterSelector>(),
Mock.Of <IModelValidatorProvider>());
// Act
var context = DefaultControllerActionArgumentBinder.GetModelBindingContext(
modelMetadata, actionBindingContext, Mock.Of <OperationBindingContext>());
// Assert
Assert.Equal("TypePrefix", context.ModelName);
}
public void MultipleValidationErrorsOnSameMemberReported()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
object model = new Address()
{
Street = "Microsoft Way"
};
// Act
Assert.DoesNotThrow(
() =>
new DefaultBodyModelValidator().Validate(
model,
typeof(Address),
metadataProvider,
actionContext,
string.Empty
)
);
// Assert
Assert.Contains("Street", actionContext.ModelState.Keys);
ModelState streetState = actionContext.ModelState["Street"];
Assert.Equal(2, streetState.Errors.Count);
}
public void ExcludedPropertyTypes_AreShallowValidated()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
Mock <DefaultBodyModelValidator> mockValidator = new Mock <DefaultBodyModelValidator>();
mockValidator.CallBase = true;
mockValidator
.Setup(validator => validator.ShouldValidateType(typeof(Person)))
.Returns(false);
// Act
mockValidator.Object.Validate(
new Pet(),
typeof(Pet),
metadataProvider,
actionContext,
string.Empty
);
// Assert
Assert.False(actionContext.ModelState.IsValid);
ModelState modelState = actionContext.ModelState["Owner"];
Assert.Single(modelState.Errors);
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomMetadata"/> class.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="containerType">Type of the container.</param>
/// <param name="modelAccessor">The model accessor.</param>
/// <param name="modelType">Type of the model.</param>
/// <param name="propertyName">Name of the property.</param>
/// <param name="displayColumnAttribute">The display column attribute.</param>
/// <param name="attributes">The attributes.</param>
public CustomMetadata(DataAnnotationsModelMetadataProvider provider, Type containerType, Func <object> modelAccessor, Type modelType, string propertyName, DisplayColumnAttribute displayColumnAttribute, IEnumerable <Attribute> attributes)
: base(provider, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute)
{
var descAttr = attributes.OfType <DescriptionAttribute>().SingleOrDefault();
_description = descAttr != null ? descAttr.Description : "";
}
public override string ProcessTag(NDjango.Interfaces.IContext context, string content, object[] parms)
{
var htmlHelperOption = context.tryfind("Html");
if (htmlHelperOption == null)
{
return("");
}
var htmlHelper = (HtmlHelper)htmlHelperOption.Value;
var metadata_provider = new DataAnnotationsModelMetadataProvider();
if (context.ModelType == null)
{
htmlHelper.ViewData.ModelMetadata = null;
}
else
{
var model = Activator.CreateInstance(context.ModelType.Value);
htmlHelper.ViewData.ModelMetadata = metadata_provider.GetMetadataForType(() => model, context.ModelType.Value);
}
var result = htmlHelper.Label(parms[0].ToString());
if (result == null)
{
return("");
}
else
{
return(result.ToHtmlString());
}
}
public virtual ActionResult PropertyItemHtml(object data, string propertyPath, int depth, string pathPrefix)
{
ViewData["propertyPath"] = (pathPrefix ?? "") + propertyPath;
ViewData["addDepth"] = depth - 1;
string parentPath = propertyPath.Contains(".") ? propertyPath.UpToLast(".") : "";
string propertyName = (propertyPath.Contains(".") ? propertyPath.LastAfter(".") : propertyPath).UpTo("[");
Type parentType = ReflectionX.GetPropertyTypeByPath(data.GetType(), parentPath);
IList list = ReflectionX.GetPropertyValueByPath(data, propertyPath, true) as IList;
var listProp = ReflectionX.GetPropertyByPath(data.GetType(), propertyPath);
Type listType = listProp.PropertyType;
if (listType.GetType().IsArray)
{
list = (IList)Array.CreateInstance(ReflectionX.ElementType(listType), 1);
list[0] = CreateInstance(listType.GetElementType());
}
else
{
list = (IList)Activator.CreateInstance(listType);
list.Add(CreateInstance(ReflectionX.ElementType(listType)));
}
ViewData["list"] = list;
var metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(null, parentType, propertyName);
ViewData["CollectionAdditionalValues"] = metadata.AdditionalValues;
RouteData.DataTokens.Add("CancelProcessingHtml", true);
return(PartialView(ConfigHelper.GetViewPath("LyniconPropertyItem.cshtml"), data));
}
public async Task TryUpdateModel_UsesModelTypeNameIfSpecified()
{
// Arrange
var modelName = "mymodel";
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var valueProvider = Mock.Of <IValueProvider>();
var binder = new Mock <IModelBinder>();
binder.Setup(b => b.BindModelAsync(It.IsAny <ModelBindingContext>()))
.Callback((ModelBindingContext context) =>
{
Assert.Equal(modelName, context.ModelName);
Assert.Same(valueProvider, context.ValueProvider);
// Include and exclude should be null, resulting in property
// being included.
Assert.True(context.PropertyFilter(context, "Property1"));
Assert.True(context.PropertyFilter(context, "Property2"));
})
.Returns(Task.FromResult(false))
.Verifiable();
var controller = GetController(binder.Object, valueProvider);
var model = new MyModel();
// Act
var result = await controller.TryUpdateModelAsync(model, modelName);
// Assert
binder.Verify();
}
public void ExpectedValidationErrorsRaised(object model, Type type, Dictionary <string, string> expectedErrors)
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
// Act
Assert.DoesNotThrow(() =>
new DefaultBodyModelValidator().Validate(model, type, metadataProvider, actionContext, string.Empty)
);
// Assert
Dictionary <string, string> actualErrors = new Dictionary <string, string>();
foreach (KeyValuePair <string, ModelState> keyStatePair in actionContext.ModelState)
{
foreach (ModelError error in keyStatePair.Value.Errors)
{
actualErrors.Add(keyStatePair.Key, error.ErrorMessage);
}
}
Assert.Equal(expectedErrors.Count, actualErrors.Count);
foreach (KeyValuePair <string, string> keyErrorPair in expectedErrors)
{
Assert.Contains(keyErrorPair.Key, actualErrors.Keys);
Assert.Equal(keyErrorPair.Value, actualErrors[keyErrorPair.Key]);
}
}
public void ReturnsCharacters()
{
// Arrange
var characters = new[] { "cadence" };
var binder = new CharactersBinder(characters);
HttpActionContext actionContext = null;
var modelName = "myModelName";
var mockValueProvider = new Mock <IValueProvider>();
mockValueProvider.Setup(v => v.GetValue("myModelName")).ReturnsValueProviderResult("cadence");
var valueProvider = mockValueProvider.Object;
var data = new DataAnnotationsModelMetadataProvider();
var modelMetadata = data.GetMetadataForType(null, typeof(Characters));
var bindingContext = new ModelBindingContext
{
ModelName = modelName,
ValueProvider = valueProvider,
ModelMetadata = modelMetadata,
};
// Act
binder.BindModel(actionContext, bindingContext);
// Assert
var model = bindingContext.Model;
Assert.IsAssignableFrom <Characters>(model);
}
private IReadOnlyList <ApiDescription> GetApiDescriptions(
ActionDescriptor action,
List <MockFormatter> formatters)
{
var context = new ApiDescriptionProviderContext(new ActionDescriptor[] { action });
var formattersProvider = new Mock <IOutputFormattersProvider>(MockBehavior.Strict);
formattersProvider.Setup(fp => fp.OutputFormatters).Returns(formatters);
var constraintResolver = new Mock <IInlineConstraintResolver>();
constraintResolver.Setup(c => c.ResolveConstraint("int"))
.Returns(new IntRouteConstraint());
var modelMetadataProvider = new DataAnnotationsModelMetadataProvider();
var provider = new DefaultApiDescriptionProvider(
formattersProvider.Object,
constraintResolver.Object,
modelMetadataProvider);
provider.Invoke(context, () => { });
return(context.Results);
}
public void PropertiesListGetsResetWhenModelGetsReset()
{ // Dev10 Bug #923263
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = new ModelMetadata(
provider,
null,
() => new Class1(),
typeof(Class1),
null
);
// Act
ModelMetadata[] originalProps = metadata.Properties.ToArray();
metadata.Model = new Class2();
ModelMetadata[] newProps = metadata.Properties.ToArray();
// Assert
ModelMetadata originalProp = Assert.Single(originalProps);
Assert.Equal(typeof(string), originalProp.ModelType);
Assert.Equal("Prop1", originalProp.PropertyName);
ModelMetadata newProp = Assert.Single(newProps);
Assert.Equal(typeof(int), newProp.ModelType);
Assert.Equal("Prop2", newProp.PropertyName);
}
public void ReflectionBuilderTest()
{
var reflectionBuilder = new ReflectionContentManagementBuilder();
var module = reflectionBuilder.BuildModuleFromAssembly(typeof(ContactInputViewModel).Assembly);
Assert.That(module.Name, Is.EqualTo("ToileDeFond.Tests.Unit.ContentManagement.Reflection"));
Assert.That(module.ContentTypes.Count(), Is.EqualTo(1));
var contentType = module.ContentTypes.First();
Assert.That(contentType.Name, Is.EqualTo("ContactInputViewModel"));
Assert.That(contentType.Properties.Count(), Is.EqualTo(5));
IContentTypeProperty nameProperty;
contentType.TryGetProperty("Name", out nameProperty);
Assert.That(nameProperty, Is.Not.Null);
var dataAnnotationsModelMetadataProvider = new DataAnnotationsModelMetadataProvider();
var contentModelmetadataBasedOnDataAnnotationsModelMetadataProvider = dataAnnotationsModelMetadataProvider
.GetMetadataForType(() => new ContactInputViewModel(), typeof(ContactInputViewModel));
var nameMedata = contentModelmetadataBasedOnDataAnnotationsModelMetadataProvider.Properties.Single(p => p.DisplayName == "Nom");
//TODO: Tester l'overriding du metadata
//TODO: Tester l'ensemble des propriétés metadata
Assert.That(nameMedata, Is.Not.Null);
//Assert.That(nameMedata.DisplayName, Is.EqualTo(nameProperty.DisplayName));
}
public void GetModelBindingContext_ModelBindingContextIsNotSet_ForTypes(
string actionMethodName, bool expectedFallToEmptyPrefix, string expectedModelName)
{
// Arrange
var type = typeof(ControllerActionArgumentBinderTests);
var methodInfo = type.GetMethod(actionMethodName);
var actionContext = new ActionContext(
new RouteContext(Mock.Of <HttpContext>()),
Mock.Of <ActionDescriptor>());
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var modelMetadata = metadataProvider.GetMetadataForParameter(modelAccessor: null,
methodInfo: methodInfo,
parameterName: "parameter1");
// Act
var context = DefaultControllerActionArgumentBinder.GetModelBindingContext(
modelMetadata,
actionContext,
Mock.Of <OperationBindingContext>());
// Assert
Assert.Equal(expectedFallToEmptyPrefix, context.FallbackToEmptyPrefix);
Assert.Equal(expectedModelName, context.ModelName);
}
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 ModelMetadata CreateMetaData(Type type)
{
var meta = new DataAnnotationsModelMetadataProvider();
return(meta.GetMetadataForType(null, type));
//return new ModelMetadata(new EmptyModelMetadataProvider(), null, null, type, null);
}
public void ReturnsLeaderboardIdParams()
{
// Arrange
var binder = new LeaderboardIdParamsBinder();
HttpActionContext actionContext = null;
var modelName = "myModelName";
var mockValueProvider = new Mock <IValueProvider>();
mockValueProvider.Setup(v => v.GetValue(modelName)).ReturnsValueProviderResult("2047616,2047493");
var valueProvider = mockValueProvider.Object;
var data = new DataAnnotationsModelMetadataProvider();
var modelMetadata = data.GetMetadataForType(null, typeof(LeaderboardIdParams));
var bindingContext = new ModelBindingContext
{
ModelName = modelName,
ValueProvider = valueProvider,
ModelMetadata = modelMetadata,
};
// Act
binder.BindModel(actionContext, bindingContext);
// Assert
var model = bindingContext.Model;
Assert.IsAssignableFrom <LeaderboardIdParams>(model);
}
private static ModelMetadata GetMetadataForType(Type t)
{
DataAnnotationsModelMetadataProvider metadataProvider =
new DataAnnotationsModelMetadataProvider();
return(metadataProvider.GetMetadataForType(null, t));
}
private static ModelMetadata GetMetadataForObject(object o)
{
DataAnnotationsModelMetadataProvider metadataProvider =
new DataAnnotationsModelMetadataProvider();
return(metadataProvider.GetMetadataForType(() => o, o.GetType()));
}
public void GetValidators_ReturnsDateValidator()
{
ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(null, typeof(ProviderModel), "Date");
IEnumerable <Type> actual = provider.GetValidators(metadata, new ControllerContext()).Select(validator => validator.GetType());
IEnumerable <Type> expected = new[] { typeof(DateValidator) };
Assert.Equal(expected, actual);
}
public void GetValidators_GetsNumericValidator()
{
ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(null, typeof(ProviderModel), "Numeric");
IEnumerable actual = provider.GetValidators(metadata, new ControllerContext()).Select(validator => validator.GetType());
IEnumerable expected = new[] { typeof(NumberValidator) };
CollectionAssert.AreEqual(expected, actual);
}
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 RegisterAdapters_RegistersAdapter(String property, Type adapter)
{
DataAnnotationsModelValidatorProvider annotations = new DataAnnotationsModelValidatorProvider();
ModelMetadata metadata = new DataAnnotationsModelMetadataProvider()
.GetMetadataForProperty(null, typeof(AdaptersModel), property);
application.RegisterAdapters();
Assert.Single(annotations.GetValidators(metadata, new ControllerContext()), validator => validator.GetType() == adapter);
}
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 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 SimpleDisplayNameWithUnknownDisplayColumnThrows()
{
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
ExceptionHelper.ExpectInvalidOperationException(
() => provider.GetMetadataForType(() => new UnknownDisplayColumnModel(), typeof(UnknownDisplayColumnModel)).SimpleDisplayText,
"System.Web.Mvc.Test.DataAnnotationsModelMetadataProviderTest+UnknownDisplayColumnModel has a DisplayColumn attribute for NoPropertyWithThisName, but property NoPropertyWithThisName does not exist.");
}
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 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 ReadOnlyTests()
{
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
IModelFlattener test = new DefaultModelFlattener();
var model = new DisplayModel();
var result = test.Flatten(model, model.GetType(), provider, string.Empty);
Assert.NotNull(result);
}
public void GetMetadataForTypeSetsTypeWithNullPropertyName() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
ModelMetadata result = provider.GetMetadataForType(null, typeof(string));
// Assert
Assert.AreEqual(typeof(string), result.ModelType);
Assert.IsNull(result.PropertyName);
}
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 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 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 GetMetadataForPropertiesSetTypesAndPropertyNames() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act
IEnumerable<ModelMetadata> result = provider.GetMetadataForProperties("foo", typeof(string));
// Assert
Assert.IsTrue(result.Any(m => m.ModelType == typeof(int)
&& m.PropertyName == "Length"
&& (int)m.Model == 3));
}
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 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 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 SettingViewData_AlsoUpdatesViewBag()
{
// Arrange
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var controller = new Controller();
var originalViewData = controller.ViewData = new ViewDataDictionary<object>(metadataProvider);
var replacementViewData = new ViewDataDictionary<object>(metadataProvider);
// Act
controller.ViewBag.Hello = "goodbye";
controller.ViewData = replacementViewData;
controller.ViewBag.Another = "property";
// Assert
Assert.NotSame(originalViewData, controller.ViewData);
Assert.Same(replacementViewData, controller.ViewData);
Assert.Null(controller.ViewBag.Hello);
Assert.Equal("property", controller.ViewBag.Another);
Assert.Equal("property", controller.ViewData["Another"]);
}
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 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 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 AttributesOverrideMetadataStrings(Attribute attribute, Func<ModelMetadata, string> accessor)
{
// Arrange
var attributes = new[] { attribute };
var provider = new DataAnnotationsModelMetadataProvider();
// Act
var metadata = new CachedDataAnnotationsModelMetadata(
provider,
containerType: null,
modelType: typeof(ClassWithDisplayableColumn),
propertyName: null,
attributes: attributes)
{
Model = new ClassWithDisplayableColumn { Property = "value" },
};
var result = accessor(metadata);
// Assert
Assert.Equal("value", result);
}
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 void Constructor_DefersDefaultsToBaseModelMetadata()
{
// Arrange
var attributes = Enumerable.Empty<Attribute>();
var provider = new DataAnnotationsModelMetadataProvider();
// Act
var metadata = new CachedDataAnnotationsModelMetadata(
provider,
containerType: null,
modelType: typeof(object),
propertyName: null,
attributes: attributes);
// Assert
Assert.True(metadata.ConvertEmptyStringToNull);
Assert.False(metadata.IsReadOnly);
Assert.False(metadata.IsRequired);
Assert.Null(metadata.Description);
Assert.Null(metadata.DisplayName);
Assert.Null(metadata.NullDisplayText);
}
private static ModelMetadata GetMetadataForCanUpdateProperty(string propertyName)
{
DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
return metadataProvider.GetMetadataForProperty(null, typeof(MyModelTestingCanUpdateProperty), propertyName);
}
public void SimpleDisplayTextForNullClassRevertsToDefaultBehavior() {
// Arrange
string expected = "Null Display Text";
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
ModelMetadata metadata = provider.GetMetadataForType(null, typeof(SimpleDisplayTextAttributeModel));
metadata.NullDisplayText = expected;
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.AreEqual(expected, result);
}
public void PropertiesListGetsResetWhenModelGetsReset()
{ // Dev10 Bug #923263
// Arrange
var provider = new DataAnnotationsModelMetadataProvider();
var metadata = new ModelMetadata(provider, null, () => new Class1(), typeof(Class1), null);
// Act
ModelMetadata[] originalProps = metadata.Properties.ToArray();
metadata.Model = new Class2();
ModelMetadata[] newProps = metadata.Properties.ToArray();
// Assert
ModelMetadata originalProp = Assert.Single(originalProps);
Assert.Equal(typeof(string), originalProp.ModelType);
Assert.Equal("Prop1", originalProp.PropertyName);
ModelMetadata newProp = Assert.Single(newProps);
Assert.Equal(typeof(int), newProp.ModelType);
Assert.Equal("Prop2", newProp.PropertyName);
}
public void SimpleDisplayTextForNonNullClassWithNullDisplayColumnValueRevertsToDefaultBehavior() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
SimpleDisplayTextAttributeModel model = new SimpleDisplayTextAttributeModel();
ModelMetadata metadata = provider.GetMetadataForType(() => model, typeof(SimpleDisplayTextAttributeModel));
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.AreEqual("42", result); // Falls back to the default logic of first property value
}
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 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 SimpleDisplayTextForNonNullClassWithNonNullDisplayColumnValue() {
// Arrange
string expected = "Custom property display value";
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
SimpleDisplayTextAttributeModel model = new SimpleDisplayTextAttributeModel { DisplayColumnProperty = expected };
ModelMetadata metadata = provider.GetMetadataForType(() => model, typeof(SimpleDisplayTextAttributeModel));
// Act
string result = metadata.SimpleDisplayText;
// Assert
Assert.AreEqual(expected, result);
}
private static ModelMetadata GetMetadataForObject(object o)
{
DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
return metadataProvider.GetMetadataForType(() => o, o.GetType());
}
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 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);
}
private static ModelMetadata GetMetadataForType(Type t)
{
DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
return metadataProvider.GetMetadataForType(null, t);
}
public void SimpleDisplayTextForTypeWithWriteOnlyDisplayColumnThrows() {
// Arrange
DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
// Act & Assert
ExceptionHelper.ExpectInvalidOperationException(
() => provider.GetMetadataForType(() => new WriteOnlyDisplayColumnModel(), typeof(WriteOnlyDisplayColumnModel)).SimpleDisplayText,
"System.Web.Mvc.Test.DataAnnotationsModelMetadataProviderTest+WriteOnlyDisplayColumnModel has a DisplayColumn attribute for WriteOnlyProperty, but property WriteOnlyProperty does not have a public getter.");
ExceptionHelper.ExpectInvalidOperationException(
() => provider.GetMetadataForType(() => new PrivateReadPublicWriteDisplayColumnModel(), typeof(PrivateReadPublicWriteDisplayColumnModel)).SimpleDisplayText,
"System.Web.Mvc.Test.DataAnnotationsModelMetadataProviderTest+PrivateReadPublicWriteDisplayColumnModel has a DisplayColumn attribute for PrivateReadPublicWriteProperty, but property PrivateReadPublicWriteProperty does not have a public getter.");
}
