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_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 void Validate_ComplexReferenceType_Invalid_MultipleErrorsOnProperty_EmptyPrefix()
{
// Arrange
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
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(actionContext, 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);
}
public void Validate_ComplexReferenceType_Valid()
{
// Arrange
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new ReferenceType()
{
Reference = "ref", Value = 256
};
modelState.SetModelValue("parameter.Reference", "ref", "ref");
modelState.SetModelValue("parameter.Value", "256", "256");
validationState.Add(model, new ValidationStateEntry()
{
Key = "parameter"
});
// Act
validator.Validate(actionContext, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter.Reference", "parameter.Value");
var entry = modelState["parameter.Reference"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["parameter.Value"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
private ModelResult <Post> addPost <T>(T postInput, Func <Post> generatePost)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(T), validator.Validate(postInput));
if (!validationState.IsValid)
{
return(new ModelResult <Post>(validationState));
}
Guid siteID = context.Site.ID;
Post post;
using (TransactionScope transaction = new TransactionScope())
{
post = generatePost();
validatePost(siteID, post, validationState);
if (!validationState.IsValid)
{
return(new ModelResult <Post>(validationState));
}
post = repository.Save(post);
//TODO: (eripo) Save a search result for this post
invalidateCachedPostDependencies(post);
transaction.Complete();
}
return(new ModelResult <Post>(post, validationState));
}
public ModelResult <Role> EditRole(RoleAddress roleAddress, RoleInput roleInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(RoleInput), validator.Validate(roleInput));
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
Role originalRole;
Role newRole;
using (TransactionScope transaction = new TransactionScope())
{
originalRole = repository.GetRole(roleAddress.RoleName);
newRole = originalRole.Apply(roleInput);
validateRole(newRole, originalRole, validationState);
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
newRole = repository.Save(newRole);
transaction.Complete();
}
pluginEngine.ExecuteAll("RoleSaved", new { context, role = new RoleReadOnly(newRole) });
pluginEngine.ExecuteAll("RoleEdited", new { context, role = new RoleReadOnly(newRole), roleOriginal = new RoleReadOnly(originalRole) });
return(new ModelResult <Role>(newRole, validationState));
}
public void Validate_ForExcludedComplexType_PropertiesMarkedAsSkipped()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
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, validatorProvider, 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_ComplexReferenceType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new Person();
validationState.Add(model, new ValidationStateEntry()
{
Key = string.Empty
});
// Act
validator.Validate(actionContext, validatorProvider, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "Name", "Profession");
var entry = modelState["Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Name"), error.ErrorMessage);
entry = modelState["Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
}
private ModelResult <Blog> editBlog <T>(Blog blog, T input, Func <Blog, Blog> applyInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(T), validator.Validate(input));
if (!validationState.IsValid)
{
return(new ModelResult <Blog>(validationState));
}
Blog originalBlog = blog;
Blog newBlog;
using (TransactionScope transaction = new TransactionScope())
{
newBlog = applyInput(originalBlog);
validateBlog(newBlog, originalBlog, validationState);
if (!validationState.IsValid)
{
return(new ModelResult <Blog>(validationState));
}
newBlog = repository.Save(newBlog);
invalidateCachedBlogForEdit(newBlog, originalBlog);
transaction.Complete();
}
pluginEngine.ExecuteAll("BlogEdited", new { context, blog = new BlogReadOnly(newBlog), blogOriginal = new BlogReadOnly(originalBlog) });
return(new ModelResult <Blog>(newBlog, validationState));
}
public void AddPostWithoutTrackbacks(Post post, User creator, 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;
}
repository.Save(post);
newPost = repository.GetPost(post.ID);
if (site.AuthorAutoSubscribe && !repository.GetSubscriptionExists(newPost, creator))
{
repository.AddSubscription(newPost, creator);
}
}
public void Validate_IndexedCollectionTypes_Valid(object model, Type type)
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
modelState.SetModelValue("items[0]", "value1", "value1");
modelState.SetModelValue("items[1]", "value2", "value2");
modelState.SetModelValue("items[2]", "value3", "value3");
validationState.Add(model, new ValidationStateEntry()
{
Key = "items",
// Force the validator to treat it as the specified type.
Metadata = MetadataProvider.GetMetadataForType(type),
});
// Act
validator.Validate(actionContext, validatorProvider, 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 void Validate_ComplexReferenceType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new Person();
validationState.Add(model, new ValidationStateEntry() { Key = string.Empty });
// Act
validator.Validate(actionContext, validatorProvider, validationState, string.Empty, model);
// Assert
Assert.False(modelState.IsValid);
AssertKeysEqual(modelState, "Name", "Profession");
var entry = modelState["Name"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
var error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Name"), error.ErrorMessage);
entry = modelState["Profession"];
Assert.Equal(ModelValidationState.Invalid, entry.ValidationState);
error = Assert.Single(entry.Errors);
Assert.Equal(ValidationAttributeUtil.GetRequiredErrorMessage("Profession"), error.ErrorMessage);
}
public void Validate_CollectionType_DictionaryOfComplexType_Invalid()
{
// Arrange
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
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(actionContext, 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_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_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_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_ComplexReferenceType_Valid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = (object)new ReferenceType() { Reference = "ref", Value = 256 };
modelState.SetModelValue("parameter.Reference", "ref", "ref");
modelState.SetModelValue("parameter.Value", "256", "256");
validationState.Add(model, new ValidationStateEntry() { Key = "parameter" });
// Act
validator.Validate(validatorProvider, modelState, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter.Reference", "parameter.Value");
var entry = modelState["parameter.Reference"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["parameter.Value"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public virtual object SaveItem(Site siteInput, User userInput, FormCollection form)
{
ValidationStateDictionary validationState;
if (siteInput.ID == Guid.Empty && userInput != null)
{
//TODO: (erikpo) This seems lame, but I need to do validation ahead of time. Fix this.
IUnityContainer container = (IUnityContainer)HttpContext.Application["container"];
IValidator <Site> siteValidator = container.Resolve <IValidator <Site> >();
IValidator <User> userValidator = container.Resolve <IValidator <User> >();
validationState = new ValidationStateDictionary();
validationState.Add(typeof(Site), siteValidator.Validate(siteInput));
validationState.Add(typeof(User), userValidator.Validate(userInput));
if (string.IsNullOrEmpty(form["userEmail"]))
{
validationState[typeof(User)].Errors.Add("Email", form["userEmail"], "You must specify an Admin email address.");
}
if (string.IsNullOrEmpty(form["userPassword"]))
{
validationState[typeof(User)].Errors.Add("Password", form["userPassword"], "You must specify an Admin password.");
}
if (string.IsNullOrEmpty(form["userPasswordConfirm"]))
{
validationState[typeof(User)].Errors.Add("PasswordConfirm", form["userPasswordConfirm"], "You must confirm the Admin password.");
}
if (validationState.IsValid && form["userPassword"] != form["userPasswordConfirm"])
{
validationState[typeof(User)].Errors.Add("PasswordMismatch", form["userPasswordConfirm"], "Admin passwords do not match.");
}
if (validationState.IsValid)
{
Site site;
siteService.AddSite(siteInput, out validationState, out site);
Language language = new Language {
Name = "en", DisplayName = "English"
};
languageService.AddLanguage(language);
userService.EnsureAnonymousUser(language);
User user;
userInput.Status = (byte)EntityState.Normal;
userInput.LanguageDefault = language;
userService.AddUser(userInput, out validationState, out user);
Area area = new Area
{
CommentingDisabled = false,
Name = "Blog",
DisplayName = site.DisplayName,
Description = site.Description
};
areaService.AddArea(area, site, out validationState, out area);
}
}
else
{
siteService.EditSite(siteInput, out validationState);
}
if (!validationState.IsValid)
{
ModelState.AddModelErrors(validationState);
return(Item());
}
OxiteApplication.Load(ControllerContext.HttpContext);
return(Redirect(Url.AppPath(Url.ManageSite())));
}
public void UserChangePassword(string userName, string oldPassword, string newPassword, string confirmNewPassword, ref ValidationStateDictionary states)
{
ValidationState v = new ValidationState();
if (string.IsNullOrEmpty(oldPassword))
{
v.Errors.Add(new ValidationError("OldPassword.InvalidOldPassword", oldPassword, "Old Password is not set"));
}
if (string.IsNullOrEmpty(newPassword))
{
v.Errors.Add(new ValidationError("NewPassword.InvalidNewPassword", newPassword, "New Password is not set"));
}
else if (newPassword.Length < 8)
{
v.Errors.Add(new ValidationError("NewPassword.InvalidNewPassword", newPassword, string.Format("New Password minimum length is {0}", 8)));
}
if (string.IsNullOrEmpty(confirmNewPassword))
{
v.Errors.Add(new ValidationError("ConfirmNewPassword.InvalidConfirmPassword", confirmNewPassword, "Confirm New Password is not set"));
}
else if (newPassword.Length < 8)
{
v.Errors.Add(new ValidationError("ConfirmNewPassword.InvalidNewPassword", newPassword, string.Format("Confirm Password minimum length is {0}", 8)));
}
if (confirmNewPassword != newPassword)
{
v.Errors.Add(new ValidationError("ConfirmNewPassword.ConfirmPasswordNotMatch", confirmNewPassword, "Password and confirm password not equal."));
}
if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(newPassword))
{
if (userName.ToLower() == newPassword.ToLower())
{
v.Errors.Add(new ValidationError("NewPassword.ConfirmPasswordNotMatch", newPassword, "Password cannot be user name."));
}
}
var userObject = repositoryInstance.GetUser(userName);
if (userObject == null)
{
v.Errors.Add(new ValidationError("OldPassword.InvalidAccountDetails", userName, "Invalid user details, please check and try again."));
}
else
{
if (userObject.AccountType != Constants.AccountType.LocalFinacle && userObject.AccountType != Constants.AccountType.LocalLocal)
{
v.Errors.Add(new ValidationError("OldPassword.InvalidAccountDetails", userName, "Password cannot be changed. Please contact your administrator"));
}
}
if ((int)Utility.PasswordAdvisor.CheckStrength(newPassword) < 4)
{
v.Errors.Add(new ValidationError("Password.ComplexityViolationError", newPassword, "Password failed the company's password complexity policy check."));
}
if (!v.IsValid)
{
states.Add(typeof(ChangePasswordDto), v);
return;
}
var storePassword = userObject.Password;
var settings = SecurityConfig.GetCurrent();
if (settings.Cookie.PasswordHashed)
{
oldPassword = PasswordHash.Hash(userName.ToLower(), oldPassword);
newPassword = PasswordHash.Hash(userName.ToLower(), newPassword);
}
if (oldPassword != storePassword)
{
v.Errors.Add(new ValidationError("OldPassword.InvalidOldPassword", oldPassword, "Password change not successful. Old password is incorrect."));
states.Add(typeof(ChangePasswordDto), v);
return;
}
int unUsablePreviousPasswordCount = 0;
if (passwordHistoryServiceInstance.IsRepeatingPassword(new PasswordHistoryModel()
{
UserName = userName, Password = newPassword
}, out unUsablePreviousPasswordCount))
{
v.Errors.Add(new ValidationError("NewPassword.PreviouslyUsedError", oldPassword, "Password change not successful. Last " + unUsablePreviousPasswordCount + " Passwords cannot be used."));
states.Add(typeof(ChangePasswordDto), v);
return;
}
repositoryInstance.ResetUserPassword(userName, newPassword, false);
passwordHistoryServiceInstance.InsertPassword(new PasswordHistoryModel()
{
UserName = userName, Password = newPassword
});
}
//public bool ActivateAccount(string activationCode)
//{
// return repositoryInstance.ActivateAccount(activationCode);
//}
public void ResetPassword(string username, string email, ref ValidationStateDictionary states)
{
ValidationState v = new ValidationState();
string firstName = string.Empty;
if (string.IsNullOrEmpty(username))
{
v.Errors.Add(new ValidationError("Username.UsernameRequired", null, "Username is not set."));
}
if (v.Errors.Count > 0)
{
states.Add(typeof(ChangePasswordDto), v);
return;
}
var userObject = repositoryInstance.GetUser(username);
if (userObject == null)
{
v.Errors.Add(new ValidationError("Username.InvalidAccountDetails", username, "Invalid user details, please check and try again."));
}
else
{
if (userObject.AccountType != Constants.AccountType.LocalFinacle && userObject.AccountType != Constants.AccountType.LocalLocal)
{
v.Errors.Add(new ValidationError("Username.InvalidAccountDetails", username, "Password cannot be changed. Please contact your administrator"));
}
}
if (v.Errors.Count > 0)
{
states.Add(typeof(ChangePasswordDto), v);
return;
}
if (string.IsNullOrEmpty(email))
{
v.Errors.Add(new ValidationError("Email.EmailRequired", null, "Email is not set."));
}
else
{
if (!Helper.IsEmailValid(email))
{
v.Errors.Add(new ValidationError("Email.EmailInvalid", null, "Email is Invalid."));
}
if (userObject.Username.ToLower() != username.ToLower() || userObject.Email.ToLower() != email.ToLower())
{
v.Errors.Add(new ValidationError("Username.UsernameAndEmailNotMatch", username, "Unable to do a password reset for this details."));
}
}
if (v.Errors.Count > 0)
{
states.Add(typeof(ChangePasswordDto), v);
return;
}
string newPassword = (new PasswordGenerator()).GeneratePassword(12);
var hashedPassword = string.Empty;
var settings = SecurityConfig.GetCurrent();
if (settings.Cookie.PasswordHashed)
{
hashedPassword = PasswordHash.Hash(username.ToLower(), newPassword);
}
else
{
hashedPassword = newPassword;
}
repositoryInstance.ResetUserPassword(username, hashedPassword, true);
bool status = SendPasswordResetMail(username, firstName, email, newPassword);
if (!status)
{
v.Errors.Add(new ValidationError("Username.UnableToRetrievePassword", username, "Unable to do a password reset for this details."));
states.Add(typeof(ChangePasswordDto), v);
}
return;
}
public AuthenticationDataDto SignIn(string username, string password, bool sessionBased, ref ValidationStateDictionary states)
{
ValidationState v = new ValidationState();
if (string.IsNullOrEmpty(username))
{
v.Errors.Add(new ValidationError("Username.UsernameRequiredError", username, "Username is not set."));
}
if (string.IsNullOrEmpty(password))
{
v.Errors.Add(new ValidationError("Password.PasswordRequiredError", password, "Password is not set"));
}
if (v.Errors.Count > 0)
{
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
var userObject = repositoryInstance.GetUser(username);
if (userObject == null)
{
v.Errors.Add(new ValidationError("Password.InvalidUsername", username, "Invalid Username or Password"));
states.Add(typeof(LogInDto), v);
return(null);
}
string lastLogin = userObject.LastLogInDate.HasValue ?
userObject.LastLogInDate.Value.ToString("dd-MM-yyyy HH:mm:ss")
: Helper.GetLocalDate().ToString("dd-MM-yyyy HH:mm:ss");
cacheService.AddAndTieToSession(string.Format("UserLastLogIn-{0}", userObject.Username), lastLogin);
var roleID = GetRoleList().Where(f => f.RoleName == Constants.General.AdministratorRoleName).Select(r => r.RoleId).FirstOrDefault();
if (!IsBusinessHour())
{
//allow administrator log in outside business hours.
if (roleID != userObject.RoleId)
{
v.Errors.Add(new ValidationError("User.NonBusinessHoursLoginError", username, "Login outside business hours is not allowed, Please try logging in during business hours."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
//Check if account is not locked,is approved and not deleted.
if ((userObject.ApprovalStatus != Constants.ApprovalStatus.Approved) || userObject.IsLockedOut || userObject.IsDeleted)
{
v.Errors.Add(new ValidationError("Username.AccountLocked", username, "This account is inactive, has been locked or has been Deleted."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
//check if user is Dormented.
if (userObject.LastLogInDate == null)
{
//exclude administrator account from being dormant
if (roleID != userObject.RoleId)
{
int dormentNumberOfDays = NewUserIDDormentNumberDays();
if ((Helper.GetLocalDate() - (DateTime)userObject.CreationDate).Days >= dormentNumberOfDays)
{
UpdateUserDetails(userObject, isDorment: true);
v.Errors.Add(new ValidationError("Username.AccountDormented", username, "This account is Dormant as user has not logged for " + dormentNumberOfDays + " days from the day of account creation. Please contact the administrator."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
}
//prevent multi terminal login
if (userObject.IsOnline)
{
var settings = SecurityConfig.GetCurrent();
var timeOutDate = Helper.GetLocalDate().AddMinutes(settings.Cookie.Timeout * -1);
if (userObject.LastActivityDate.HasValue && userObject.LastActivityDate.Value >= timeOutDate)
{
v.Errors.Add(new ValidationError("Username.MultiTeminalLogin", username, "You are currently logged in on another terminal. Kindly log out there and retry."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
//if last log in date/last activity date more than 90 days ago, refuse log in and lock the account
if (userObject.LastLogInDate.HasValue && userObject.LastLogInDate.Value.Date < Helper.GetLocalDate().AddDays(ActiveUserIDDormentNumberDays()))
{
//exclude administrator account from being dormant
if (roleID != userObject.RoleId)
{
repositoryInstance.UpdateBadPasswordCount(username, true);
UpdateUserDetails(userObject, isDorment: true);
v.Errors.Add(new ValidationError("Username.AccountDormented", username, "This account is Dormant. Please contact the administrator."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
//Check if the Account is Expired
if (userObject.AccountExpiryDate != null)
{
if (userObject.AccountExpiryDate < DateTime.Now)
{
//exclude administrator account from expiring
if (roleID != userObject.RoleId)
{
UpdateUserDetails(userObject, isAccountExpired: true);
v.Errors.Add(new ValidationError("Username.AccountExpired", username, "This account is Expired. Please contact the administrator."));
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
}
if (userObject.Password != "Dummy" && (userObject.AccountType == Constants.AccountType.LocalLocal || userObject.AccountType == Constants.AccountType.LocalFinacle))
{
//check the password match
if (userObject.Password != password)
{
//v.Errors.Add(new ValidationError("Username.InvalidUsername", username, "Invalid Username or Password"));
v.Errors.Add(new ValidationError("Password.InvalidPassword", password, "Invalid Username or Password"));
var settings = SecurityConfig.GetCurrent();
var lockAccount = userObject.BadPasswordCount + 1 >= settings.Cookie.MaximumPasswordRetries;
repositoryInstance.UpdateBadPasswordCount(username, lockAccount);
states.Add(typeof(LogInDto), v);
return(new AuthenticationDataDto()
{
AppAuthenticationFailed = true
});
}
}
AuthenticationDataDto auth = new AuthenticationDataDto();
{
auth.SessionId = Helper.GetNextGuid().ToString();
auth.Username = username;
auth.Roles = userObject.UserRole != null ? userObject.UserRole.RoleName : null;
auth.BranchCode = userObject.BranchID;
auth.IsFirstLogIn = userObject.IsFirstLogIn;
auth.FullName = string.Format("{0} {1}", userObject.FirstName, userObject.LastName);
auth.IsPasswordSet = userObject.Password != "Dummy" && (userObject.AccountType == Constants.AccountType.LocalLocal || userObject.AccountType == Constants.AccountType.LocalFinacle);
auth.IsRoleSet = userObject.AccountType == Constants.AccountType.ADLocal || userObject.AccountType == Constants.AccountType.LocalLocal; // userObject.UserRole != null && !string.IsNullOrEmpty(userObject.UserRole.RoleName);
auth.AccountType = userObject.AccountType;
}
if (sessionBased)
{
UpdateLogInSucceed(username, auth.SessionId);
}
return(auth);
}
public virtual object SaveItem(Site siteInput, UserInputAdd userInput)
{
ValidationStateDictionary validationState;
if (siteInput.ID == Guid.Empty && userInput != null)
{
//TODO: (erikpo) This is lame. Add a SiteInput class and a SiteInputValidator class and move the following validation code into it.
IUnityContainer container = (IUnityContainer)HttpContext.Application["container"];
IValidator <Site> siteValidator = container.Resolve <IValidator <Site> >();
validationState = new ValidationStateDictionary();
validationState.Add(typeof(Site), siteValidator.Validate(siteInput));
if (validationState.IsValid)
{
Site site;
siteService.AddSite(siteInput, out validationState, out site);
Language language = new Language {
Name = "en", DisplayName = "English"
};
languageService.AddLanguage(language);
userService.EnsureAnonymousUser();
//UserAuthenticated user;
//userInput.Status = (byte)EntityState.Normal;
//userInput.LanguageDefault = language;
//userService.AddUser(userInput, out validationState, out user);
if (validationState.IsValid)
{
//Blog blog = new Blog
//{
// CommentingDisabled = false,
// Name = "Blog",
// DisplayName = site.DisplayName,
// Description = site.Description
//};
//blogService.AddBlog(blog, site, out validationState, out blog);
}
}
}
else
{
siteService.EditSite(siteInput, out validationState);
}
if (!validationState.IsValid)
{
ModelState.AddModelErrors(validationState);
return(Item());
}
OxiteApplication.Load(ControllerContext.HttpContext);
return(Redirect(Url.AppPath(Url.ManageSite())));
}
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_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_SuppressValidation()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var modelState = new ModelStateDictionary();
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = new Person2()
{
Name = "Billy",
Address = new Address { Street = "GreaterThan5Characters" }
};
modelState.SetModelValue("person.Name", "Billy", "Billy");
modelState.SetModelValue("person.Address.Street", "GreaterThan5Characters", "GreaterThan5Characters");
validationState.Add(model, new ValidationStateEntry() { Key = "person" });
validationState.Add(model.Address, new ValidationStateEntry()
{
Key = "person.Address",
SuppressValidation = true
});
// Act
validator.Validate(validatorProvider, modelState, validationState, "person", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "person.Name", "person.Address.Street");
var entry = modelState["person.Name"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["person.Address.Street"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
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 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);
}
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);
}
public void ValidatePost(Post post, out ValidationStateDictionary validationState)
{
validationState = new ValidationStateDictionary();
validationState.Add(typeof(Post), validator.Validate(post));
}
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_DictionaryOfSimpleType_Invalid()
{
// Arrange
var validatorProvider = CreateValidatorProvider();
var actionContext = new ActionContext();
var modelState = actionContext.ModelState;
var validationState = new ValidationStateDictionary();
var validator = CreateValidator();
var model = new Dictionary<string, string>()
{
{ "FooKey", "FooValue" },
{ "BarKey", "BarValue" }
};
modelState.SetModelValue("items[0].Key", "key0", "key0");
modelState.SetModelValue("items[0].Value", "value0", "value0");
modelState.SetModelValue("items[1].Key", "key1", "key1");
modelState.SetModelValue("items[1].Value", "value1", "value1");
validationState.Add(model, new ValidationStateEntry() { Key = "items" });
// Act
validator.Validate(actionContext, validatorProvider, 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.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[0].Value"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[1].Key"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
entry = modelState["items[1].Value"];
Assert.Equal(ModelValidationState.Valid, entry.ValidationState);
Assert.Empty(entry.Errors);
}
public void AddComment(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);
}
if (comment.State == EntityState.Normal)
{
repository.SaveMessages(generateMessages(post, comment));
}
newComment = repository.GetComment(comment.ID);
}
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_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_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_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_SimpleType_SuppressValidation()
{
// 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", SuppressValidation = true });
// Act
validator.Validate(actionContext, validatorProvider, validationState, "parameter", model);
// Assert
Assert.True(modelState.IsValid);
AssertKeysEqual(modelState, "parameter");
var entry = modelState["parameter"];
Assert.Equal(ModelValidationState.Skipped, entry.ValidationState);
Assert.Empty(entry.Errors);
}
