public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { var model = context.Model; var result = validator.Validate(model); var errors = result.Errors; return errors.Select(error => new ModelValidationResult(error.PropertyName, error.ErrorMessage)); }
public void Validate_SetsMemberName_OnValidationContext_ForProperties( ModelMetadata metadata, object container, object model, string expectedMemberName) { // Arrange var attribute = new Mock<TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny<object>(), It.IsAny<ValidationContext>())) .Callback((object o, ValidationContext context) => { Assert.Equal(expectedMemberName, context.MemberName); }) .Returns(ValidationResult.Success) .Verifiable(); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var results = validator.Validate(validationContext); // Assert Assert.Empty(results); attribute.VerifyAll(); }
private bool ValidateProperties( string currentModelKey, ModelExplorer modelExplorer, ValidationContext validationContext) { var isValid = true; foreach (var property in modelExplorer.Metadata.Properties) { var propertyExplorer = modelExplorer.GetExplorerForProperty(property.PropertyName); var propertyMetadata = propertyExplorer.Metadata; var propertyValidationContext = new ValidationContext() { ModelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, propertyExplorer), Visited = validationContext.Visited }; var propertyBindingName = propertyMetadata.BinderModelName ?? propertyMetadata.PropertyName; var childKey = ModelBindingHelper.CreatePropertyModelName(currentModelKey, propertyBindingName); if (!ValidateNonVisitedNodeAndChildren( childKey, propertyValidationContext, validators: null)) { isValid = false; } } return(isValid); }
public void Validate_SetsMemberName_OnValidationContext_ForProperties( ModelMetadata metadata, object container, object model, string expectedMemberName) { // Arrange var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Callback((object o, ValidationContext context) => { Assert.Equal(expectedMemberName, context.MemberName); }) .Returns(ValidationResult.Success) .Verifiable(); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var results = validator.Validate(validationContext); // Assert Assert.Empty(results); attribute.VerifyAll(); }
// Validates a single node (not including children) // Returns true if validation passes successfully private static bool ShallowValidate( string modelKey, ModelExplorer modelExplorer, ValidationContext validationContext, IList <IModelValidator> validators) { var isValid = true; var modelState = validationContext.ModelValidationContext.ModelState; var fieldValidationState = modelState.GetFieldValidationState(modelKey); if (fieldValidationState == ModelValidationState.Invalid) { // Even if we have no validators it's possible that model binding may have added a // validation error (conversion error, missing data). We want to still run // validators even if that's the case. isValid = false; } // When the are no validators we bail quickly. This saves a GetEnumerator allocation. // In a large array (tens of thousands or more) scenario it's very significant. if (validators == null || validators.Count > 0) { var modelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, modelExplorer); var modelValidationState = modelState.GetValidationState(modelKey); // If either the model or its properties are unvalidated, validate them now. if (modelValidationState == ModelValidationState.Unvalidated || fieldValidationState == ModelValidationState.Unvalidated) { foreach (var validator in validators) { foreach (var error in validator.Validate(modelValidationContext)) { var errorKey = ModelBindingHelper.CreatePropertyModelName(modelKey, error.MemberName); if (!modelState.TryAddModelError(errorKey, error.Message) && modelState.GetFieldValidationState(errorKey) == ModelValidationState.Unvalidated) { // If we are not able to add a model error // for instance when the max error count is reached, mark the model as skipped. modelState.MarkFieldSkipped(errorKey); } isValid = false; } } } } if (isValid) { validationContext.ModelValidationContext.ModelState.MarkFieldValid(modelKey); } return(isValid); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { var model = context.Model; var result = _validator.Validate(model); return from error in result.Errors select new ModelValidationResult(error.PropertyName, error.ErrorMessage); }
/// <summary> /// Constructs a new instance of the <see cref="ModelValidationContext"/> class using the /// <paramref name="parentContext" /> and <paramref name="modelExplorer"/>. /// </summary> /// <param name="parentContext">Existing <see cref="ModelValidationContext"/>.</param> /// <param name="modelExplorer"><see cref="ModelExplorer"/> associated with the new /// <see cref="ModelValidationContext"/>.</param> /// <returns></returns> public static ModelValidationContext GetChildValidationContext( [NotNull] ModelValidationContext parentContext, [NotNull] ModelExplorer modelExplorer) { return(new ModelValidationContext( modelExplorer.Metadata.BindingSource, parentContext.ValidatorProvider, parentContext.ModelState, modelExplorer)); }
/// <summary> /// Validates a single node in a model object graph. /// </summary> /// <returns><c>true</c> if the node is valid, otherwise <c>false</c>.</returns> protected virtual bool ValidateNode() { var state = _modelState.GetValidationState(_key); if (state == ModelValidationState.Unvalidated) { var validators = GetValidators(_metadata); var count = validators.Count; if (count > 0) { var context = new ModelValidationContext() { Container = _container, Model = _model, Metadata = _metadata, }; var results = new List <ModelValidationResult>(); for (var i = 0; i < count; i++) { results.AddRange(validators[i].Validate(context)); } var resultsCount = results.Count; for (var i = 0; i < resultsCount; i++) { var result = results[i]; var key = ModelNames.CreatePropertyModelName(_key, result.MemberName); _modelState.TryAddModelError(key, result.Message); } } } state = _modelState.GetFieldValidationState(_key); if (state == ModelValidationState.Invalid) { return(false); } else { // If the field has an entry in ModelState, then record it as valid. Don't create // extra entries if they don't exist already. var entry = _modelState[_key]; if (entry != null) { entry.ValidationState = ModelValidationState.Valid; } return(true); } }
/// <inheritdoc /> public void Validate([NotNull] ModelValidationContext modelValidationContext) { var validationContext = new ValidationContext() { ModelValidationContext = modelValidationContext, Visited = new HashSet <object>(ReferenceEqualityComparer.Instance), }; ValidateNonVisitedNodeAndChildren( modelValidationContext.RootPrefix, validationContext, validators: null); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { var modelExplorer = context.ModelExplorer; var metadata = modelExplorer.Metadata; var memberName = metadata.PropertyName ?? metadata.ModelType.Name; var containerExplorer = modelExplorer.Container; var container = containerExplorer?.Model; var model = container ?? modelExplorer.Model; var result = _validator.Validate(model); return from error in result.Errors select new ModelValidationResult(error.PropertyName, error.ErrorMessage); }
/// <inheritdoc /> public void Validate( [NotNull] ModelValidationContext modelValidationContext, [NotNull] ModelValidationNode validationNode) { var validationContext = new ValidationContext() { ModelValidationContext = modelValidationContext, Visited = new HashSet <object>(ReferenceEqualityComparer.Instance), ValidationNode = validationNode }; ValidateNonVisitedNodeAndChildren( validationNode.Key, validationContext, validators: null); }
private bool ValidateElements(string currentKey, IEnumerable model, ValidationContext validationContext) { var elementType = GetElementType(model.GetType()); var elementMetadata = _modelMetadataProvider.GetMetadataForType(elementType); var validatorProvider = validationContext.ModelValidationContext.ValidatorProvider; var validatorProviderContext = new ModelValidatorProviderContext(elementMetadata); validatorProvider.GetValidators(validatorProviderContext); var validators = validatorProviderContext.Validators; // If there are no validators or the object is null we bail out quickly // when there are large arrays of null, this will save a significant amount of processing // with minimal impact to other scenarios. var anyValidatorsDefined = validators.Any(); var index = 0; var isValid = true; foreach (var element in model) { // If the element is non null, the recursive calls might find more validators. // If it's null, then a shallow validation will be performed. if (element != null || anyValidatorsDefined) { var elementExplorer = new ModelExplorer(_modelMetadataProvider, elementMetadata, element); var elementKey = ModelBindingHelper.CreateIndexModelName(currentKey, index); var elementValidationContext = new ValidationContext() { ModelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, elementExplorer), Visited = validationContext.Visited }; if (!ValidateNonVisitedNodeAndChildren(elementKey, elementValidationContext, validators)) { isValid = false; } } index++; } return(isValid); }
private bool ValidateChildNodes( string currentModelKey, ModelExplorer modelExplorer, ValidationContext validationContext) { var isValid = true; ExpandValidationNode(validationContext, modelExplorer); IList <IModelValidator> validators = null; if (modelExplorer.Metadata.IsCollectionType && modelExplorer.Model != null) { var enumerableModel = (IEnumerable)modelExplorer.Model; var elementType = GetElementType(enumerableModel.GetType()); var elementMetadata = _modelMetadataProvider.GetMetadataForType(elementType); validators = GetValidators(validationContext.ModelValidationContext.ValidatorProvider, elementMetadata); } foreach (var childNode in validationContext.ValidationNode.ChildNodes) { var childModelExplorer = childNode.ModelMetadata.MetadataKind == Metadata.ModelMetadataKind.Type ? _modelMetadataProvider.GetModelExplorerForType(childNode.ModelMetadata.ModelType, childNode.Model) : modelExplorer.GetExplorerForProperty(childNode.ModelMetadata.PropertyName); var propertyValidationContext = new ValidationContext() { ModelValidationContext = ModelValidationContext.GetChildValidationContext( validationContext.ModelValidationContext, childModelExplorer), Visited = validationContext.Visited, ValidationNode = childNode }; if (!ValidateNonVisitedNodeAndChildren( childNode.Key, propertyValidationContext, validators)) { isValid = false; } } return(isValid); }
public IEnumerable <ModelValidationResult> Validate(ModelValidationContext validationContext) { var metadata = validationContext.Metadata; var memberName = metadata.PropertyName ?? metadata.ModelType.Name; var container = validationContext.Container; var context = new ValidationContext(container ?? validationContext.Model) { DisplayName = metadata.GetDisplayName(), MemberName = memberName }; var result = Attribute.GetValidationResult(validationContext.Model, context); if (result != ValidationResult.Success) { // ModelValidationResult.MemberName is used by invoking validators (such as ModelValidator) to // construct the ModelKey for ModelStateDictionary. When validating at type level we want to append // the returned MemberNames if specified (e.g. person.Address.FirstName). For property validation, the // ModelKey can be constructed using the ModelMetadata and we should ignore MemberName (we don't want // (person.Name.Name). However the invoking validator does not have a way to distinguish between these // two cases. Consequently we'll only set MemberName if this validation returns a MemberName that is // different from the property being validated. var errorMemberName = result.MemberNames.FirstOrDefault(); if (string.Equals(errorMemberName, memberName, StringComparison.Ordinal)) { errorMemberName = null; } string errorMessage = null; if (_stringLocalizer != null && !string.IsNullOrEmpty(Attribute.ErrorMessage) && string.IsNullOrEmpty(Attribute.ErrorMessageResourceName) && Attribute.ErrorMessageResourceType == null) { errorMessage = _stringLocalizer[Attribute.ErrorMessage]; } var validationResult = new ModelValidationResult(errorMemberName, errorMessage ?? result.ErrorMessage); return(new ModelValidationResult[] { validationResult }); } return(Enumerable.Empty <ModelValidationResult>()); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext validationContext) { var metadata = validationContext.Metadata; var memberName = metadata.PropertyName ?? metadata.ModelType.Name; var container = validationContext.Container; var context = new ValidationContext(container ?? validationContext.Model) { DisplayName = metadata.GetDisplayName(), MemberName = memberName }; var result = Attribute.GetValidationResult(validationContext.Model, context); if (result != ValidationResult.Success) { // ModelValidationResult.MemberName is used by invoking validators (such as ModelValidator) to // construct the ModelKey for ModelStateDictionary. When validating at type level we want to append // the returned MemberNames if specified (e.g. person.Address.FirstName). For property validation, the // ModelKey can be constructed using the ModelMetadata and we should ignore MemberName (we don't want // (person.Name.Name). However the invoking validator does not have a way to distinguish between these // two cases. Consequently we'll only set MemberName if this validation returns a MemberName that is // different from the property being validated. var errorMemberName = result.MemberNames.FirstOrDefault(); if (string.Equals(errorMemberName, memberName, StringComparison.Ordinal)) { errorMemberName = null; } string errorMessage = null; if (_stringLocalizer != null && !string.IsNullOrEmpty(Attribute.ErrorMessage) && string.IsNullOrEmpty(Attribute.ErrorMessageResourceName) && Attribute.ErrorMessageResourceType == null) { errorMessage = _stringLocalizer[Attribute.ErrorMessage]; } var validationResult = new ModelValidationResult(errorMemberName, errorMessage ?? result.ErrorMessage); return new ModelValidationResult[] { validationResult }; } return Enumerable.Empty<ModelValidationResult>(); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { var model = context.ModelExplorer.Model; if (model == null) { return Enumerable.Empty<ModelValidationResult>(); } var validatable = model as IValidatableObject; if (validatable == null) { var message = Resources.FormatValidatableObjectAdapter_IncompatibleType( typeof(IValidatableObject).Name, model.GetType()); throw new InvalidOperationException(message); } var validationContext = new ValidationContext(validatable, serviceProvider: null, items: null); return ConvertResults(validatable.Validate(validationContext)); }
public void Validate_IsValidFalse_StringLocalizerReturnsLocalizerErrorMessage() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock <ValidationAttribute> { CallBase = true }; attribute.Setup(a => a.IsValid(model)).Returns(false); attribute.Object.ErrorMessage = "Length"; var localizedString = new LocalizedString("Length", "Longueur est invalide"); var stringLocalizer = new Mock <IStringLocalizer>(); stringLocalizer.Setup(s => s["Length"]).Returns(localizedString); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer.Object); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var result = validator.Validate(validationContext); // Assert var validationResult = result.Single(); Assert.Equal("", validationResult.MemberName); Assert.Equal("Longueur est invalide", validationResult.Message); }
public void Validate_ReturnsSingleValidationResult_IfMemberNameSequenceIsEmpty() { // Arrange const string errorMessage = "Some error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock <TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny <object>(), It.IsAny <ValidationContext>())) .Returns(new ValidationResult(errorMessage, memberNames: null)); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var results = validator.Validate(validationContext); // Assert var validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Empty(validationResult.MemberName); }
public void Validate_SetsMemberName_OnValidationContext_ForProperties( ModelMetadata metadata, object container, object model, string expectedMemberName) { // Arrange var attribute = new Mock <TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny <object>(), It.IsAny <ValidationContext>())) .Callback((object o, ValidationContext context) => { Assert.Equal(expectedMemberName, context.MemberName); }) .Returns(ValidationResult.Success) .Verifiable(); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var results = validator.Validate(validationContext); // Assert Assert.Empty(results); attribute.VerifyAll(); }
public IEnumerable <ModelValidationResult> Validate(ModelValidationContext context) { var model = context.ModelExplorer.Model; if (model == null) { return(Enumerable.Empty <ModelValidationResult>()); } var validatable = model as IValidatableObject; if (validatable == null) { var message = Resources.FormatValidatableObjectAdapter_IncompatibleType( typeof(IValidatableObject).Name, model.GetType()); throw new InvalidOperationException(message); } var validationContext = new ValidationContext(validatable, serviceProvider: null, items: null); return(ConvertResults(validatable.Validate(validationContext))); }
public void Validate_ReturnsSingleValidationResult_IfOneMemberNameIsSpecified() { // Arrange const string errorMessage = "A different error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(object)); var model = new object(); var attribute = new Mock <TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny <object>(), It.IsAny <ValidationContext>())) .Returns(new ValidationResult(errorMessage, new[] { "FirstName" })); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: null, model: model); // Act var results = validator.Validate(validationContext); // Assert ModelValidationResult validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Equal("FirstName", validationResult.MemberName); }
public void Validate_ReturnsSingleValidationResult_IfOneMemberNameIsSpecified() { // Arrange const string errorMessage = "A different error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(object)); var model = new object(); var attribute = new Mock<TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny<object>(), It.IsAny<ValidationContext>())) .Returns(new ValidationResult(errorMessage, new[] { "FirstName" })); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: null, model: model); // Act var results = validator.Validate(validationContext); // Assert ModelValidationResult validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Equal("FirstName", validationResult.MemberName); }
public void Validate_ReturnsMemberName_IfItIsDifferentFromDisplayName() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(SampleModel)); var model = new SampleModel(); var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Returns(new ValidationResult("Name error", new[] { "Name" })); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Model = model, }; // Act var results = validator.Validate(validationContext); // Assert ModelValidationResult validationResult = Assert.Single(results); Assert.Equal("Name", validationResult.MemberName); }
public void Validate_ReturnsSingleValidationResult_IfOneMemberNameIsSpecified() { // Arrange const string errorMessage = "A different error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(object)); var model = new object(); var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Returns(new ValidationResult(errorMessage, new[] { "FirstName" })); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Model = model, }; // Act var results = validator.Validate(validationContext); // Assert ModelValidationResult validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Equal("FirstName", validationResult.MemberName); }
public void Validate_IsValidFalse_StringLocalizerReturnsLocalizerErrorMessage() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Setup(a => a.IsValid(model)).Returns(false); attribute.Object.ErrorMessage = "Length"; var localizedString = new LocalizedString("Length", "Longueur est invalide"); var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s["Length"]).Returns(localizedString); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer.Object); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var result = validator.Validate(validationContext); // Assert var validationResult = result.Single(); Assert.Equal("", validationResult.MemberName); Assert.Equal("Longueur est invalide", validationResult.Message); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { throw new NotImplementedException(); }
/// <summary> /// Validates a single node in a model object graph. /// </summary> /// <returns><c>true</c> if the node is valid, otherwise <c>false</c>.</returns> protected virtual bool ValidateNode() { var state = _modelState.GetValidationState(_key); if (state == ModelValidationState.Unvalidated) { var validators = GetValidators(); var count = validators.Count; if (count > 0) { var context = new ModelValidationContext( _actionContext, _metadata, _metadataProvider, _container, _model); var results = new List<ModelValidationResult>(); for (var i = 0; i < count; i++) { results.AddRange(validators[i].Validate(context)); } var resultsCount = results.Count; for (var i = 0; i < resultsCount; i++) { var result = results[i]; var key = ModelNames.CreatePropertyModelName(_key, result.MemberName); _modelState.TryAddModelError(key, result.Message); } } } state = _modelState.GetFieldValidationState(_key); if (state == ModelValidationState.Invalid) { return false; } else { // If the field has an entry in ModelState, then record it as valid. Don't create // extra entries if they don't exist already. var entry = _modelState[_key]; if (entry != null) { entry.ValidationState = ModelValidationState.Valid; } return true; } }
public IEnumerable <ModelValidationResult> Validate(ModelValidationContext context) { throw new NotImplementedException(); }
public IEnumerable<ModelValidationResult> Validate(ModelValidationContext context) { return Enumerable.Empty<ModelValidationResult>(); }
public void Validate_Valid() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Setup(a => a.IsValid(model)).Returns(true); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var result = validator.Validate(validationContext); // Assert Assert.Empty(result); }
public void Validate_IsValidFalse_StringLocalizerGetsArguments( ValidationAttribute attribute, string model, object[] values) { // Arrange var stringLocalizer = new Mock<IStringLocalizer>(); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute, stringLocalizer.Object); var metadata = _metadataProvider.GetMetadataForType(typeof(SampleModel)); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: null, model: model); // Act validator.Validate(validationContext); // Assert var json = Newtonsoft.Json.JsonConvert.SerializeObject(values) + " " + attribute.GetType().Name; stringLocalizer.Verify(l => l[LocalizationKey, values], json); }
public void Validate_IsValidFalse_StringLocalizerReturnsLocalizerErrorMessage() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var attribute = new MaxLengthAttribute(4); attribute.ErrorMessage = "{0} should have no more than {1} characters."; var localizedString = new LocalizedString(attribute.ErrorMessage, "Longueur est invalide : 4"); var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s[attribute.ErrorMessage, It.IsAny<object[]>()]).Returns(localizedString); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute, stringLocalizer.Object); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: "abcde"); // Act var result = validator.Validate(validationContext); // Assert var validationResult = result.Single(); Assert.Equal("", validationResult.MemberName); Assert.Equal("Longueur est invalide : 4", validationResult.Message); }
public void Validate_ReturnsSingleValidationResult_IfMemberNameSequenceIsEmpty() { // Arrange const string errorMessage = "Some error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Returns(new ValidationResult(errorMessage, memberNames: null)); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var results = validator.Validate(validationContext); // Assert var validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Empty(validationResult.MemberName); }
public void Validate_Invalid() { // Arrange var metadata = _metadataProvider.GetMetadataForProperty(typeof(string), "Length"); var container = "Hello"; var model = container.Length; var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Setup(a => a.IsValid(model)).Returns(false); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var result = validator.Validate(validationContext); // Assert var validationResult = result.Single(); Assert.Equal("", validationResult.MemberName); Assert.Equal(attribute.Object.FormatErrorMessage("Length"), validationResult.Message); }
public void Validate_ReturnsSingleValidationResult_IfMemberNameSequenceIsEmpty() { // Arrange const string errorMessage = "Some error message"; var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock<TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny<object>(), It.IsAny<ValidationContext>())) .Returns(new ValidationResult(errorMessage, memberNames: null)); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: container, model: model); // Act var results = validator.Validate(validationContext); // Assert var validationResult = Assert.Single(results); Assert.Equal(errorMessage, validationResult.Message); Assert.Empty(validationResult.MemberName); }
public void Validate_ReturnsMemberName_IfItIsDifferentFromDisplayName() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(SampleModel)); var model = new SampleModel(); var attribute = new Mock<TestableValidationAttribute> { CallBase = true }; attribute .Setup(p => p.IsValidPublic(It.IsAny<object>(), It.IsAny<ValidationContext>())) .Returns(new ValidationResult("Name error", new[] { "Name" })); var validator = new DataAnnotationsModelValidator( new ValidationAttributeAdapterProvider(), attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext( actionContext: new ActionContext(), modelMetadata: metadata, metadataProvider: _metadataProvider, container: null, model: model); // Act var results = validator.Validate(validationContext); // Assert ModelValidationResult validationResult = Assert.Single(results); Assert.Equal("Name", validationResult.MemberName); }
public void Validatate_ValidationResultSuccess() { // Arrange var metadata = _metadataProvider.GetMetadataForType(typeof(string)); var container = "Hello"; var model = container.Length; var attribute = new Mock<ValidationAttribute> { CallBase = true }; attribute.Protected() .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>()) .Returns(ValidationResult.Success); var validator = new DataAnnotationsModelValidator(attribute.Object, stringLocalizer: null); var validationContext = new ModelValidationContext() { Metadata = metadata, Container = container, Model = model, }; // Act var result = validator.Validate(validationContext); // Assert Assert.Empty(result); }