public void Validate_SimpleReferenceType_Valid_WithPrefix()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)"test";
modelState.SetModelValue("parameter", "test", "test");
validationState.Add(model, new ValidationStateEntry()
{
Key = "parameter"
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public IndexValidationVisitor(
ModelStateDictionary modelState,
IIndexModelValidatorProvider validatorProvider,
IndexValidatorCache validatorCache,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
{
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
if (validatorCache == null)
{
throw new ArgumentNullException(nameof(validatorCache));
}
_validatorProvider = validatorProvider;
_validatorCache = validatorCache;
_metadataProvider = metadataProvider;
_validationState = validationState;
_modelState = modelState;
_currentPath = new ValidationStack();
}
//TODO: (erikpo) This is lame and should be removed once we have "events" this can be avoided
public void AddCommentWithoutMessages(Area area, Post post, Comment comment, UserBase creator, bool subscribe, out ValidationStateDictionary validationState, out Comment newComment)
{
validationState = new ValidationStateDictionary();
comment.Creator = creator;
if (comment.State == EntityState.NotSet)
{
try
{
comment.State = creator is User
? EntityState.Normal
: (EntityState)Enum.Parse(typeof(EntityState), site.CommentStateDefault);
}
catch
{
comment.State = EntityState.PendingApproval;
}
}
if (comment.Language == null)
{
comment.Language = post.Creator.LanguageDefault;
}
validationState.Add(typeof(Comment), validator.Validate(comment));
//validate anonymous users
if (!(comment.Creator is User))
{
validationState.Add(typeof(UserBase), validator.Validate(comment.Creator));
comment.Creator.HashedEmail = !string.IsNullOrEmpty(comment.Creator.Email) ? comment.Creator.Email.ComputeHash() : "";
}
//validation for subscription
//todo: (nheskew) moooove and unhack a bit - _feels_ wrong here
if (subscribe)
{
validationState.Add(typeof(PostSubscription), validator.Validate(new PostSubscription {
Post = post, User = comment.Creator
}));
}
if (!validationState.IsValid)
{
newComment = null;
return;
}
repository.SaveComment(post, comment);
if (subscribe && !repository.GetSubscriptionExists(post, creator))
{
repository.AddSubscription(post, creator);
}
newComment = repository.GetComment(comment.ID);
}
public void Validate_SimpleType_MaxErrorsReached()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)"test";
modelState.MaxAllowedErrors = 1;
modelState.AddModelError("other.Model", "error");
modelState.SetModelValue("parameter", "test", "test");
validationState.Add(model, new ValidationStateEntry()
{
Key = "parameter"
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, string.Empty, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public ModelResult <PostComment> AddComment(Post post, CommentInputForImport commentInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(CommentInputForImport), validator.Validate(commentInput));
if (!validationState.IsValid)
{
return(new ModelResult <PostComment>(validationState));
}
PostComment comment;
using (TransactionScope transaction = new TransactionScope())
{
string commentSlug = generateUniqueCommentSlug(post);
comment = commentInput.ToComment(commentSlug);
comment = blogsCommentRepository.Save(comment, post.Blog.Name, post.Slug);
invalidateCachedCommentDependencies(comment);
transaction.Complete();
}
PostSmallReadOnly postProxy = new PostSmallReadOnly(comment.Post);
CommentReadOnly commentProxy = new CommentReadOnly(comment, urlHelper.AbsolutePath(urlHelper.Comment(comment)));
pluginEngine.ExecuteAll("CommentAddedFromImport", new { context, parent = postProxy, comment = commentProxy });
return(new ModelResult <PostComment>(comment, validationState));
}
/// <inheritdoc />
public void Validate(
IModelValidatorProvider validatorProvider,
ModelStateDictionary modelState,
ValidationStateDictionary validationState,
string prefix,
object model)
{
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
if (modelState == null)
{
throw new ArgumentNullException(nameof(modelState));
}
var visitor = new ValidationVisitor(
validatorProvider,
_excludeFilters,
modelState,
validationState);
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.Validate(metadata, prefix, model);
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Gig gig = (Gig)domainObject;
if (gig.Name == string.Empty)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.GIG_NEEDS_A_NAME);
}
else if (gig.Name.Length > 100)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.GIG_NAME_IS_TOO_LONG);
}
if (gig.Description.Length > 6000)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.GIG_DESCRIPTION_IS_TOO_LONG);
}
if (gig.Venue== null)
{
validationStateDictionary.AddValidationError("Venue", ValidationStateKeys.GIG_NEEDS_A_VENUE);
}
if (gig.Acts == null || (gig.Acts!=null && gig.Acts.Count==0))
{
validationStateDictionary.AddValidationError("Acts", ValidationStateKeys.GIG_NEEDS_AT_LEAST_ONE_ACT);
}
return validationStateDictionary;
}
public void Validate_ForExcludedComplexType_PropertiesMarkedAsSkipped()
{
// Arrange
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(typeof(User));
var model = new User()
{
Password = "******",
ConfirmPassword = "******"
};
// Note that user.ConfirmPassword has no entry in modelstate - we should not
// create one just to mark it as skipped.
modelState.SetModelValue("user.Password", "password-val", "password-val");
validationState.Add(model, new ValidationStateEntry()
{
Key = "user",
});
// Act
validator.Validate(actionContext, validationState, "user", model);
// Assert
Assert.Equal(ModelValidationState.Valid, modelState.ValidationState);
AssertKeysEqual(modelState, "user.Password");
var entry = modelState["user.Password"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model)
{
var requiredErrorsNotHandledByFv = RemoveImplicitRequiredErrors(actionContext);
// Apply any customizations made with the CustomizeValidatorAttribute
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
if (model != null)
{
var customizations = GetCustomizations(actionContext, model.GetType(), prefix);
actionContext.HttpContext.Items["_FV_Customizations"] = Tuple.Create(model, customizations);
}
// Setting as to whether we should run only FV or FV + the other validator providers
var validatorProvider = _runMvcValidation ? _compositeProvider : _fvProvider;
var visitor = new FluentValidationVisitor(
actionContext,
validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState)
{
ValidateChildren = _implicitValidationEnabled
};
visitor.Validate(metadata, prefix, model);
// Re-add errors that we took out if FV didn't add a key.
ReApplyImplicitRequiredErrorsNotHandledByFV(requiredErrorsNotHandledByFv);
// Remove duplicates. This can happen if someone has implicit child validation turned on and also adds an explicit child validator.
RemoveDuplicateModelstateEntries(actionContext);
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Track track = (Track)domainObject;
if (track.Style == null)
{
validationStateDictionary.AddValidationError("Style", ValidationStateKeys.TRACK_NEEDS_A_STYLE);
}
if (track.Artist == null)
{
validationStateDictionary.AddValidationError("Artist", ValidationStateKeys.TRACK_NEEDS_AN_ARTIST);
}
if (track.Name.Trim() == string.Empty)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.TRACK_NEEDS_A_NAME);
}
if (track.Data == null)
{
validationStateDictionary.AddValidationError("Data", ValidationStateKeys.TRACK_NEEDS_AN_MP3);
}
else if( !ListenTo.Shared.Helpers.TrackHelpers.TrackContainsMP3Data(track))
{
validationStateDictionary.AddValidationError("Data", ValidationStateKeys.TRACK_NEEDS_A_VALID_MP3);
}
return validationStateDictionary;
}
public Plugin InstallPlugin(PluginInstallInput pluginInstallInput, bool?overrideEnabled)
{
PluginContainer pluginContainer = null;
if (!string.IsNullOrEmpty(pluginInstallInput.VirtualPath))
{
pluginContainer = pluginEngine.GetPlugins(p => (p.Tag == null || !(p.Tag is Plugin)) && p.CompilationAssembly != null && string.Compare(p.VirtualPath, pluginInstallInput.VirtualPath, true) == 0).FirstOrDefault();
}
if (pluginContainer == null)
{
throw new InvalidOperationException("Could not find plugin to install");
}
ValidationStateDictionary validationState = ValidatePlugin(pluginContainer);
Plugin plugin = repository.Save(new Plugin(context.Site.ID, pluginInstallInput.VirtualPath, validationState.IsValid && overrideEnabled.HasValue ? overrideEnabled.Value : validationState.IsValid, pluginContainer.GetPropertiesUsingDefaultValues()));
plugin.Container = pluginContainer;
pluginContainer.Tag = plugin;
pluginContainer.IsValid = validationState.IsValid;
pluginTemplateRegistry.Reload(pluginEngine);
context.Routes.Reload(modules, this, pluginEngine);
pluginStyleRegistry.Reload(pluginEngine);
pluginScriptRegistry.Reload(pluginEngine);
return(plugin);
}
public void Validate_SimpleType_MaxErrorsReached()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)"test";
modelState.MaxAllowedErrors = 1;
modelState.AddModelError("other.Model", "error");
modelState.SetModelValue("parameter", "test", "test");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, string.Empty, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
/// <summary>
/// Gönderilen nesneyi valide eder
/// </summary>
/// <param name="actionContext">Uygulama context i ile ilişkili istek context i</param>
/// <param name="validationState">Model için validasyon davranışını özelleştirmek amacıyla validasyon durumunu izlemek için kullanılır</param>
/// <param name="prefix">Model öneki. Model nesnesini validationState içindeki girişlerle eşlemek için kullanılır</param>
/// <param name="model">Model nesnesi</param>
public void Validate(
ActionContext actionContext,
ValidationStateDictionary validationState,
string prefix,
object model)
{
}
protected virtual ValidationStateDictionary TryValidateModel(ActionContext actionContext, object model, string prefix = "")
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
_modelValidator.Validate(actionContext, validationState, prefix, model);
return(validationState);
}
public void Validate_SimpleReferenceType_Valid_WithPrefix()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)"test";
modelState.SetModelValue("parameter", "test", "test");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public ActionResult EditRole(RoleViewModel model)
{
{
ValidationStateDictionary states = new ValidationStateDictionary();
var updated = _securityService.EditRole(model, ref states);
if (!states.IsValid)
{
var errorList = ValidationHelper.BuildModelErrorList(states);
Danger(string.Format("{0}<br />{1}", Constants.Messages.ErrorNotice, errorList), true);
ModelState.AddModelErrors(states);
SetAuditInfo(Helper.StripHtml(errorList, true), string.Empty);
return(View(model));
}
else
{
if (updated == 0)
{
Warning(Constants.Messages.ConcurrencyError, true);
}
else
{
Success(Constants.Messages.SaveSuccessful, true);
}
return(RedirectToAction("EditRole", new { id = model.CurrentRole.RoleId }));
}
}
}
public void AddPost(Post post, User creator, bool fireEvents, out ValidationStateDictionary validationState, out Post newPost)
{
validationState = new ValidationStateDictionary();
post.Creator = creator;
validationState.Add(typeof(Post), validator.Validate(post));
if (!validationState.IsValid)
{
newPost = null;
return;
}
if (fireEvents)
{
events.FireEvent("PostSaving", post);
}
repository.Save(post);
newPost = repository.GetPost(post.ID);
if (site.AuthorAutoSubscribe && !repository.GetSubscriptionExists(newPost, creator))
{
repository.AddSubscription(newPost, creator);
}
if (fireEvents)
{
events.FireEvent("PostSaved", newPost);
}
}
public void Validate_ForExcludedCollectionType_PropertiesMarkedAsSkipped()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(typeof(List <string>));
var model = new List <string>()
{
"15",
};
modelState.SetModelValue("userIds[0]", "15", "15");
validationState.Add(model, new ValidationStateEntry()
{
Key = "userIds",
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, "userIds", model);
// Assert
Assert.Equal(ModelValidationState.Valid, modelState.ValidationState);
AssertKeysEqual(modelState, "userIds[0]");
var entry = modelState["userIds[0]"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_SimpleValueType_Valid_WithPrefix()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)15;
modelState.SetModelValue("parameter", "15", "15");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
AssertKeysEqual(modelState, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_ComplexType_FieldsAreIgnored_Valid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new VariableTest()
{
test = 5
};
modelState.SetModelValue("parameter", "5", "5");
validationState.Add(model, new ValidationStateEntry()
{
Key = "parameter"
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
Assert.Equal(1, modelState.Count);
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
/// <summary>
/// Creates a new <see cref="ValidationVisitor"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/> associated with the current request.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/>.</param>
/// <param name="validatorCache">The <see cref="ValidatorCache"/> that provides a list of <see cref="IModelValidator"/>s.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="validationState">The <see cref="ValidationStateDictionary"/>.</param>
public ValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidatorCache validatorCache,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
if (validatorCache == null)
{
throw new ArgumentNullException(nameof(validatorCache));
}
Context = actionContext;
ValidatorProvider = validatorProvider;
Cache = validatorCache;
MetadataProvider = metadataProvider;
ValidationState = validationState;
ModelState = actionContext.ModelState;
CurrentPath = new ValidationStack();
}
public ActionResult ChangePassword(ChangePasswordDto model)
{
ValidationStateDictionary states = new ValidationStateDictionary();
var username = ((Identity)ControllerContext.HttpContext.User.Identity).Name;
var userToEdit = _securityService.GetUser(username);
ViewBag.IsFirstLogIn = userToEdit.IsFirstLogIn;
if (userToEdit.AccountType != Constants.AccountType.LocalLocal && userToEdit.AccountType != Constants.AccountType.LocalFinacle)
{
this.Danger(string.Format("{0}<br />{1}", Constants.Messages.EditNotPermittedError, "Password can only be changed on source system"), true);
return(View(userToEdit));
}
_securityService.UserChangePassword(username, model.OldPassword, model.NewPassword, model.ConfirmPassword, ref states);
if (!states.IsValid)
{
var errorList = ValidationHelper.BuildModelErrorList(states);
Danger(string.Format("{0}<br />{1}", Constants.Messages.ErrorNotice, errorList), true);
ModelState.AddModelErrors(states);
SetAuditInfo(Helper.StripHtml(errorList, true), JsonConvert.SerializeObject(model), username);
return(View(model));
}
else
{
Success("<b>Password change</b> was successfully saved to the database.", true);
SetAuditInfo("Successful", JsonConvert.SerializeObject(model), username);
return(View("ChangePasswordSuccess"));
}
}
public Site SetupSite(SetupInput input, out ValidationStateDictionary validationState)
{
Site site = null;
using (TransactionScope transaction = new TransactionScope())
{
site = this.CreateSite(out validationState);
if (!validationState.IsValid)
{
return(null);
}
UserInputAdd userInput = new UserInputAdd(input.AdminUserName, input.AdminDisplayName, input.AdminEmail, input.AdminPassword, input.AdminPasswordConfirm);
ModelResult <User> results = this.SetupUser(userInput);
if (!results.IsValid)
{
validationState = results.ValidationState;
return(null);
}
transaction.Complete();
}
return(site);
}
public void Validate_CollectionType_ArrayOfSimpleType_Valid_DefaultKeyPattern()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new int[] { 5, 17 };
modelState.SetModelValue("parameter[0]", "5", "17");
modelState.SetModelValue("parameter[1]", "17", "5");
validationState.Add(model, new ValidationStateEntry()
{
Key = "parameter"
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter[0]", "parameter[1]");
var entry = modelState["parameter[0]"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["parameter[0]"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
/// <inheritdoc />
public void Validate(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidationStateDictionary validationState,
string prefix,
object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.Validate(metadata, prefix, model);
}
public ValidationStateDictionary ValidateCommentInput(CommentInput commentInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(CommentInput), validator.Validate(commentInput));
return(validationState);
}
private ValidationStateDictionary validatePluginPropertyValues(PluginPropertiesInput input)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(PluginPropertiesInput), validator.Validate(input));
return(validationState);
}
/// <summary>
/// Gets a <see cref="ValidationVisitor"/> that traverses the object model graph and performs validation.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/>.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/>.</param>
/// <param name="validatorCache">The <see cref="ValidatorCache"/>.</param>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="validationState">The <see cref="ValidationStateDictionary"/>.</param>
/// <returns>A <see cref="ValidationVisitor"/> which traverses the object model graph.</returns>
public abstract ValidationVisitor GetValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
#pragma warning disable PUB0001 // Pubternal type in public API
ValidatorCache validatorCache,
#pragma warning restore PUB0001
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState);
public ValidationStateDictionary ValidatePostInput(PostInput postInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(PostInput), validator.Validate(postInput));
return(validationState);
}
public void Validate(ActionContext actionContext, IModelValidatorProvider validatorProvider,
ValidationStateDictionary validationState, string prefix, object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
// would model ever be null ??
if (model == null)
{
return;
}
// get our IValidator
var validator = _validatorFactory.GetValidator(model.GetType());
if (validator == null)
{
return;
}
foreach (var value in actionContext.ModelState.Values
.Where(v => v.ValidationState == ModelValidationState.Unvalidated))
{
// Set all unvalidated states to valid. If we end up adding an error below then that properties state
// will become ModelValidationState.Invalid and will set ModelState.IsValid to false
value.ValidationState = ModelValidationState.Valid;
}
// validate the model using Fluent Validation rules
var result = validator.Validate(model);
// add all our model errors to the modelstate
if (!string.IsNullOrEmpty(prefix))
{
prefix = prefix + ".";
}
foreach (var modelError in result.Errors)
{
// See if there's already an item in the ModelState for this key.
if (actionContext.ModelState.ContainsKey(modelError.PropertyName))
{
actionContext.ModelState[modelError.PropertyName].Errors.Clear();
}
actionContext.ModelState.AddModelError(prefix + modelError.PropertyName, modelError.ErrorMessage);
}
}
public ActionResult LogIn(LogInDto model)
{
bool IsSuccess = false;
var url = string.Empty;
var errorList = string.Empty;
if (ModelState.IsValid)
{
ValidationStateDictionary states = new ValidationStateDictionary();
bool isFirstLogIn = false;
bool status = Access.SignIn(model.Username, model.Password, model.TokenCode, _securityService, _finacleRepository, out isFirstLogIn, ref states);
if ((!states.IsValid))
{
IsSuccess = false;
errorList = ValidationHelper.BuildModelErrorList(states);
Danger(string.Format("{0}<br />{1}", Constants.Messages.ErrorNotice, errorList), true);
ModelState.AddModelErrors(states);
}
else
{
if (!String.IsNullOrEmpty(model.ReturnUrl))
{
url = model.ReturnUrl;
IsSuccess = true;
}
else
{
if (!isFirstLogIn)
{
var roleName = ((Identity)ControllerContext.HttpContext.User.Identity).Roles;
url = Helper.GetRootURL() + "/admin";
IsSuccess = true;
}
else
{
url = Helper.GetRootURL() + "/MyProfile/changepassword";
IsSuccess = true;
}
}
}
}
model.Password = "******";
SetAuditInfo(IsSuccess ? "Successful" : Helper.StripHtml(errorList, true),
JsonConvert.SerializeObject(model),
string.IsNullOrEmpty(model.Username) ? "not-supplied" : model.Username);
if (IsSuccess)
{
return(new RedirectResult(url));
}
else
{
// If we got this far, something failed, redisplay form
return(View(model));
}
}
public string AddPortalSetting(PortalSetting portalSetting, ref ValidationStateDictionary states)
{
validationState = validator.Validate(portalSetting, states);
if (validationState.IsValid)
{
return(portalSettingsRepository.AddSetting(portalSetting));
}
return(validationState.Errors[0].Message);
}
public FixedValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidatorCache validatorCache,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
: base(actionContext, validatorProvider, validatorCache, metadataProvider, validationState)
{
}
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model)
{
bool skipValidate = model != null && persistentTypes.GetOrAdd(model.GetType(), t => !typeof(IXPSimpleObject).IsAssignableFrom(t));
if (skipValidate)
{
actionContext.ModelState.Clear();
}
}
private void ObjectValidatorExecutor(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model)
{
var validationResults = new List <ValidationResult>();
var b = Validator.TryValidateObject(model, new ValidationContext(model), validationResults);
foreach (var result in validationResults)
{
actionContext.ModelState.AddModelError(result.MemberNames.FirstOrDefault(), result.ErrorMessage);
}
}
public ModelResult <Post> AddPost(PostInput postInput, EntityState state, User creator)
{
ValidationStateDictionary validationState = new ValidationStateDictionary(typeof(Post), new ValidationState());
Post post = new Post(null, null, null, false, DateTime.MinValue, creator, Guid.NewGuid(), null, DateTime.MinValue, null, null, state, null, null, null);
AddedPosts.Add(post);
return(new ModelResult <Post>(post, validationState));
}
public void AddPost(Post post, User currentUser, bool fireEvents, out ValidationStateDictionary validationState, out Post newPost)
{
validationState = new ValidationStateDictionary(typeof(Post), new ValidationState());
post.Creator = currentUser;
post.ID = Guid.NewGuid();
AddedPosts.Add(post);
newPost = post;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Comment commentDO = (Comment)domainObject;
if (commentDO.Body == string.Empty)
{
validationStateDictionary.AddValidationError(ValidationStateKeys.COMMENT_BODY_INVALID);
}
return validationStateDictionary;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Image image = (Image)domainObject;
if (image.Data == null || image.Data.Length==0)
{
validationStateDictionary.AddValidationError("Data", ValidationStateKeys.FILE_NEEDS_DATA);
}
else if(!ListenTo.Shared.Helpers.ImageHelpers.IsFileImage(image.Data))
{
validationStateDictionary.AddValidationError("Data", ValidationStateKeys.FILE_IS_NOT_AN_IMAGE);
}
return validationStateDictionary;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Artist artist = (Artist)domainObject;
if (artist.Town == null)
{
validationStateDictionary.AddValidationError("Town", ValidationStateKeys.ARTIST_NEEDS_A_TOWN);
}
if (artist.Style == null)
{
validationStateDictionary.AddValidationError("Style", ValidationStateKeys.ARTIST_NEEDS_A_STYLE);
}
if (artist.ProfileAddress == string.Empty)
{
validationStateDictionary.AddValidationError("ProfileAddress", ValidationStateKeys.ARTIST_NEEDS_A_PROFILE_ADDRESS);
}
else
{
if (!FormatHelpers.IsAlphaNumeric(artist.ProfileAddress))
{
validationStateDictionary.AddValidationError("ProfileAddress", ValidationStateKeys.ARTIST_PROFILE_ADDRESS_MUST_BE_ALPHA_NUMERIC);
}
Artist artistWithProfileAddress = ArtistManager.GetByProfileAddress(artist.ProfileAddress);
if (artistWithProfileAddress != null && artistWithProfileAddress.ID != artist.ID)
{
validationStateDictionary.AddValidationError("ProfileAddress", ValidationStateKeys.ARTIST_PROFILE_ADDRESS_MUST_BE_UNIQUE);
}
}
if (artist.Name == string.Empty)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.ARTIST_NEEDS_A_NAME);
}
if (artist.Email != string.Empty && !FormatHelpers.IsEmail(artist.Email))
{
validationStateDictionary.AddValidationError("Email", ValidationStateKeys.ARTIST_EMAIL_ADDRESS_INVALID);
}
return validationStateDictionary;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
Venue venueDO = (Venue)domainObject;
if (venueDO.Name == string.Empty)
{
validationStateDictionary.AddValidationError(ValidationStateKeys.VENUE_NEEDS_NAME);
}
if (venueDO.Name.Length > 50)
{
validationStateDictionary.AddValidationError(ValidationStateKeys.VENUE_NAME_IS_TOO_LONG);
}
return validationStateDictionary;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
NewsItem newsItem = (NewsItem)domainObject;
if (newsItem.Name.Trim() == string.Empty)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.NEWSITEM_NEEDS_A_NAME);
}
else if(newsItem.Name.Length> 50)
{
validationStateDictionary.AddValidationError("Name", ValidationStateKeys.NEWSITEM_NAME_IS_TOO_LONG);
}
if (newsItem.Description.Trim() == string.Empty)
{
validationStateDictionary.AddValidationError("Description", ValidationStateKeys.NEWSITEM_NEEDS_A_DESCRIPTION);
}
else if (newsItem.Description.Length > 200)
{
validationStateDictionary.AddValidationError("Description", ValidationStateKeys.NEWSITEM_DESCRIPTION_IS_TOO_LONG);
}
if (newsItem.Body.Trim() == string.Empty)
{
validationStateDictionary.AddValidationError("Body", ValidationStateKeys.NEWSITEM_NEEDS_A_BODY);
}
//else if (newsItem.Body.Length > 6000)
//{
// validationStateDictionary.AddValidationError("Body", ValidationStateKeys.NEWSITEM_BODY_IS_TOO_LONG);
//}
if (newsItem.TargetSites == null || newsItem.TargetSites.Count == 0) {
validationStateDictionary.AddValidationError("TargetSites", ValidationStateKeys.NEWSITEM_SHOULD_BE_PUBLISHED_TO_AT_LEAST_ONE_SITE);
}
return validationStateDictionary;
}
public ValidationStateDictionary Validate(ListenTo.Shared.DO.BaseDO domainObject, ListenTo.Shared.DO.UserCredentials userCredentials)
{
ValidationStateDictionary validationStateDictionary = new ValidationStateDictionary();
UserProfile userProfileDO = (UserProfile)domainObject;
if (userProfileDO.Forename != null && userProfileDO.Forename.Length > 50)
{
validationStateDictionary.AddValidationError("Forename", ValidationStateKeys.USERPROFILE_FORENAME_IS_TOO_LONG);
}
if (userProfileDO.Surname!=null && userProfileDO.Surname.Length > 50)
{
validationStateDictionary.AddValidationError("Surname", ValidationStateKeys.USERPROFILE_SURNAME_IS_TOO_LONG);
}
if (userProfileDO.Profile!=null && userProfileDO.Profile.Length > 1000)
{
validationStateDictionary.AddValidationError("Profile", ValidationStateKeys.USERPROFILE_PROFILE_IS_TOO_LONG);
}
return validationStateDictionary;
}
private static ModelStateDictionary AddValidationStateToModelState(ValidationStateDictionary validationStateDictionary, ModelStateDictionary modelStateDictionary, string prefix)
{
if (prefix != string.Empty)
{
prefix = prefix + ".";
}
foreach (KeyValuePair<string, ValidationState> entry in validationStateDictionary)
{
object res;
//string errorMessages;
foreach (string errorKey in entry.Value.Errors)
{
res = HttpContext.GetGlobalResourceObject("ValidationStateKeys", errorKey);
if (res != null)
{
modelStateDictionary.AddModelError(prefix + entry.Key, (string)res);
}
}
}
return modelStateDictionary;
}
/// <summary>
/// Creates a new <see cref="ValidationVisitor"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/> associated with the current request.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/>.</param>
/// <param name="validationState">The <see cref="ValidationStateDictionary"/>.</param>
public ValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
_actionContext = actionContext;
_validatorProvider = validatorProvider;
_metadataProvider = metadataProvider;
_validationState = validationState;
_modelState = actionContext.ModelState;
_currentPath = new HashSet<object>(ReferenceEqualityComparer.Instance);
}
public void Validate_DoesNotUseOverridden_GetHashCodeOrEquals()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = new TypeThatOverridesEquals[]
{
new TypeThatOverridesEquals { Funny = "hehe" },
new TypeThatOverridesEquals { Funny = "hehe" }
};
// Act & Assert (does not throw)
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
}
public void Validate_DoesntCatchExceptions_FromPropertyAccessors()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = new ThrowingProperty();
// Act & Assert
Assert.Throws(
typeof(InvalidTimeZoneException),
() =>
{
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
});
}
public void Validate_CollectionType_DictionaryOfComplexType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new Dictionary<string, Person> { { "Joe", new Person() }, { "Mark", new Person() } };
modelState.SetModelValue("[0].Key", "Joe", "Joe");
modelState.SetModelValue("[1].Key", "Mark", "Mark");
validationState.Add(model, new ValidationStateEntry() { Key = string.Empty });
// Act
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(
modelState,
"[0].Key",
"[0].Value.Name",
"[0].Value.Profession",
"[1].Key",
"[1].Value.Name",
"[1].Value.Profession");
var entry = modelState["[0].Key"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["[1].Key"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["[0].Value.Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(error.ErrorMessage, ValidationAttributeUtil.GetRequiredErrorMessage("Name"));
entry = modelState["[0].Value.Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(error.ErrorMessage, ValidationAttributeUtil.GetRequiredErrorMessage("Profession"));
entry = modelState["[1].Value.Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(error.ErrorMessage, ValidationAttributeUtil.GetRequiredErrorMessage("Name"));
entry = modelState["[1].Value.Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(error.ErrorMessage, ValidationAttributeUtil.GetRequiredErrorMessage("Profession"));
}
public void Validate_CollectionType_DictionaryOfSimpleType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(new SimpleTypesExcludeFilter());
var model = new Dictionary<string, string>()
{
{ "FooKey", "FooValue" },
{ "BarKey", "BarValue" }
};
modelState.Add("items[0].Key", new ModelStateEntry());
modelState.Add("items[0].Value", new ModelStateEntry());
modelState.Add("items[1].Key", new ModelStateEntry());
modelState.Add("items[1].Value", new ModelStateEntry());
validationState.Add(model, new ValidationStateEntry() { Key = "items" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "items", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "items[0].Key", "items[0].Value", "items[1].Key", "items[1].Value");
var entry = modelState["items[0].Key"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[0].Value"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[1].Key"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[1].Value"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_NestedComplexReferenceType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new Person() { Name = "Rick", Friend = new Person() };
modelState.SetModelValue("Name", "Rick", "Rick");
validationState.Add(model, new ValidationStateEntry() { Key = string.Empty });
// Act
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "Name", "Profession", "Friend.Name", "Friend.Profession");
var entry = modelState["Name"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
entry = modelState["Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
entry = modelState["Friend.Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Name"), error.ErrorMessage);
entry = modelState["Friend.Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
}
public void Validate_CollectionType_ArrayOfSimpleType_Valid_DefaultKeyPattern()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new int[] { 5, 17 };
modelState.SetModelValue("parameter[0]", "5", "17");
modelState.SetModelValue("parameter[1]", "17", "5");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter[0]", "parameter[1]");
var entry = modelState["parameter[0]"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["parameter[0]"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_ComplexType_ShortCircuit_WhenMaxErrorCountIsSet()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(typeof(string));
var model = new User()
{
Password = "******",
ConfirmPassword = "******"
};
modelState.MaxAllowedErrors = 2;
modelState.AddModelError("key1", "error1");
modelState.SetModelValue("user.Password", "password-val", "password-val");
modelState.SetModelValue("user.ConfirmPassword", "not-password-val", "not-password-val");
validationState.Add(model, new ValidationStateEntry() { Key = "user", });
// Act
validator.Validate(validatorProvider, modelState, validationState, "user", model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, string.Empty, "key1", "user.ConfirmPassword", "user.Password");
var entry = modelState[string.Empty];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.IsType<TooManyModelErrorsException>(error.Exception);
}
public void Validate_ComplexType_CyclesNotFollowed_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var person = new Person() { Name = "Billy" };
person.Friend = person;
var model = (object)person;
modelState.SetModelValue("parameter.Name", "Billy", "Billy");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "parameter.Name", "parameter.Profession");
var entry = modelState["parameter.Name"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["parameter.Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(error.ErrorMessage, ValidationAttributeUtil.GetRequiredErrorMessage("Profession"));
}
public void Validate_ComplexType_FieldsAreIgnored_Valid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new VariableTest() { test = 5 };
modelState.SetModelValue("parameter", "5", "5");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
Assert.Equal(1, modelState.Count);
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_ComplexType_IValidatableObject_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new ValidatableModel();
modelState.SetModelValue("parameter", "model", "model");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "parameter", "parameter.Property1", "parameter.Property2", "parameter.Property3");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal("Error1", error.ErrorMessage);
entry = modelState["parameter.Property1"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal("Error2", error.ErrorMessage);
entry = modelState["parameter.Property2"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal("Error3", error.ErrorMessage);
entry = modelState["parameter.Property3"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal("Error3", error.ErrorMessage);
}
public void Validate_ForExcludedType_PropertiesMarkedAsSkipped()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(typeof(User));
var model = new User()
{
Password = "******",
ConfirmPassword = "******"
};
// Note that user.ConfirmPassword has no entry in modelstate - we should not
// create one just to mark it as skipped.
modelState.SetModelValue("user.Password", "password-val", "password-val");
validationState.Add(model, new ValidationStateEntry() { Key = "user", });
// Act
validator.Validate(validatorProvider, modelState, validationState, "user", model);
// Assert
Assert.Equal(ModelValidationState.Valid, modelState.ValidationState);
AssertKeysEqual(modelState, "user.Password");
var entry = modelState["user.Password"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void Validate_CollectionType_ListOfComplexType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new List<Person> { new Person(), new Person() };
validationState.Add(model, new ValidationStateEntry() { Key = string.Empty });
// Act
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "[0].Name", "[0].Profession", "[1].Name", "[1].Profession");
var entry = modelState["[0].Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Name"), error.ErrorMessage);
entry = modelState["[0].Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
entry = modelState["[1].Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Name"), error.ErrorMessage);
entry = modelState["[1].Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
}
public void Validate_IndexedCollectionTypes_Valid(object model, Type type)
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator(new SimpleTypesExcludeFilter());
modelState.Add("items[0]", new ModelStateEntry());
modelState.Add("items[1]", new ModelStateEntry());
modelState.Add("items[2]", new ModelStateEntry());
validationState.Add(model, new ValidationStateEntry()
{
Key = "items",
// Force the validator to treat it as the specified type.
Metadata = MetadataProvider.GetMetadataForType(type),
});
// Act
validator.Validate(validatorProvider, modelState, validationState, "items", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "items[0]", "items[1]", "items[2]");
var entry = modelState["items[0]"];
Assert.Equal(entry.ValidationState, ModelValidationState.Valid);
Assert.Empty(entry.Errors);
entry = modelState["items[1]"];
Assert.Equal(entry.ValidationState, ModelValidationState.Valid);
Assert.Empty(entry.Errors);
entry = modelState["items[2]"];
Assert.Equal(entry.ValidationState, ModelValidationState.Valid);
Assert.Empty(entry.Errors);
}
public ValidationException(ValidationStateDictionary validationStateDictionary)
{
this._validationStateDictionary = validationStateDictionary;
}
public void Validate_ComplexReferenceType_Invalid_MultipleErrorsOnProperty_EmptyPrefix()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new Address() { Street = "Microsoft Way" };
modelState.SetModelValue("Street", "Microsoft Way", "Microsoft Way");
validationState.Add(model, new ValidationStateEntry() { Key = string.Empty });
// Act
validator.Validate(validatorProvider, modelState, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "Street");
var entry = modelState["Street"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
Assert.Equal(2, entry.Errors.Count);
var errorMessages = entry.Errors.Select(e => e.ErrorMessage);
Assert.Contains(ValidationAttributeUtil.GetStringLengthErrorMessage(null, 5, "Street"), errorMessages);
Assert.Contains(ValidationAttributeUtil.GetRegExErrorMessage("hehehe", "Street"), errorMessages);
}
