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);
}
