public static AppResultBuilder MakeInvalidAccountRegistrationResults(ModelStateDictionary modelState)
{
var builder = new AppResultBuilder();
if (modelState.ContainsKey("password") &&
modelState["password"].ValidationState == ModelValidationState.Invalid)
{
builder.FailValidation(mess: "Invalid password");
}
if (modelState.ContainsKey("confirm_password") &&
modelState["confirm_password"].ValidationState == ModelValidationState.Invalid)
{
builder.FailValidation(mess: "The password and confirm password are not matched");
}
if (modelState.ContainsKey("username") &&
modelState["username"].ValidationState == ModelValidationState.Invalid)
{
builder.FailValidation(mess: "Invalid username");
}
if (modelState.ContainsKey("DuplicateUserName") &&
modelState["DuplicateUserName"].ValidationState == ModelValidationState.Invalid)
{
builder.DuplicatedUsername();
}
return(builder);
}
public static AppResult MakeInvalidAccountRegistrationResults(ModelStateDictionary modelState)
{
var validationData = new ValidationData();
if (modelState.ContainsKey("password") &&
modelState["password"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "Invalid password", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("confirm_password") &&
modelState["confirm_password"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "The password and confirm password are not matched", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("username") &&
modelState["username"].ValidationState == ModelValidationState.Invalid)
{
validationData.Fail(mess: "Invalid username", code: Constants.AppResultCode.FailValidation);
}
if (modelState.ContainsKey("DuplicateUserName") &&
modelState["DuplicateUserName"].ValidationState == ModelValidationState.Invalid)
{
return(AppResult.DuplicatedUsername());
}
var appResult = AppResult.FailValidation(data: validationData);
return(appResult);
}
public void Question_is_required(string emptyQuestion)
{
// arrange
_model.Question = emptyQuestion;
// act
_model.Validate(_modelState);
// assert
Assert.That(_modelState.Count, Is.EqualTo(1));
Assert.That(_modelState.ContainsKey("QuestionNullOrEmpty"), Is.True);
}
public static void AddExcepition(ModelStateDictionary ModelState, Exception ex)
{
if (ex is ArgumentException)
{
var argEx = (ArgumentException) ex;
if (!ModelState.ContainsKey(argEx.ParamName)) ModelState.Add(argEx.ParamName, new ModelState());
var lines = Regex.Split(ex.Message, "\r\n");
ModelState[argEx.ParamName].Errors.Add(new ModelError(ex, lines[0]));
return;
}
if (!ModelState.ContainsKey("")) ModelState.Add("", new ModelState());
ModelState[""].Errors.Add(new ModelError(ex, ex.Message));
}
private void CopyTempDataToModelState(ModelStateDictionary modelState, TempDataDictionary tempData)
{
if (!tempData.ContainsKey(TempDataKey)) return;
var fromTempData = tempData[TempDataKey] as ModelStateDictionary;
if (fromTempData == null) return;
foreach (var pair in fromTempData)
{
if (modelState.ContainsKey(pair.Key))
{
modelState[pair.Key].Value = pair.Value.Value;
foreach (var error in pair.Value.Errors)
{
if (!modelState[pair.Key].Errors.Contains(error))
modelState[pair.Key].Errors.Add(error);
}
}
else
{
modelState.Add(pair.Key, pair.Value);
}
}
}
public void ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceedsAndIncludeErrorDetailIsFalse()
{
// Arrange
ModelStateDictionary modelState = CreateModelState();
string expectedModelStateKey = "ModelStateKey";
string expectedModelStateErrorMessage = "ModelStateErrorMessage";
ModelState originalModelStateItem = new ModelState();
originalModelStateItem.Errors.Add(new ModelError(new InvalidOperationException(),
expectedModelStateErrorMessage));
modelState.Add(expectedModelStateKey, originalModelStateItem);
bool includeErrorDetail = false;
MediaTypeFormatter expectedFormatter = CreateFormatter();
MediaTypeHeaderValue expectedMediaType = CreateMediaType();
ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
expectedMediaType);
using (HttpRequestMessage expectedRequest = CreateRequest())
{
IEnumerable <MediaTypeFormatter> expectedFormatters = CreateFormatters();
Mock <IContentNegotiator> spy = new Mock <IContentNegotiator>();
spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
negotiationResult);
IContentNegotiator contentNegotiator = spy.Object;
IHttpActionResult result = CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator,
expectedRequest, expectedFormatters);
// Act
Task <HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
task.WaitUntilCompleted();
using (HttpResponseMessage response = task.Result)
{
Assert.NotNull(response);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
HttpContent content = response.Content;
Assert.IsType <ObjectContent <HttpError> >(content);
ObjectContent <HttpError> typedContent = (ObjectContent <HttpError>)content;
HttpError error = (HttpError)typedContent.Value;
Assert.NotNull(error);
HttpError modelStateError = error.ModelState;
Assert.NotNull(modelStateError);
Assert.True(modelState.ContainsKey(expectedModelStateKey));
object modelStateValue = modelStateError[expectedModelStateKey];
Assert.IsType(typeof(string[]), modelStateValue);
string[] typedModelStateValue = (string[])modelStateValue;
Assert.Equal(1, typedModelStateValue.Length);
Assert.Same(expectedModelStateErrorMessage, typedModelStateValue[0]);
Assert.Same(expectedFormatter, typedContent.Formatter);
Assert.NotNull(typedContent.Headers);
Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
Assert.Same(expectedRequest, response.RequestMessage);
}
}
}
public static string[] ModelStateValue(ModelStateDictionary modelState, string name, bool isList)
{
if (!modelState.ContainsKey(name))
{
return(null);
}
var value = modelState[name];
if (value == null)
{
return(null);
}
if (isList)
{
var enumerable = value.RawValue as IEnumerable;
if (enumerable != null && !(enumerable is string))
{
return(enumerable.Cast <object>().Select(o => Convert.ToString(o)).ToArray());
}
}
return(new string[] { value.AttemptedValue });
}
/// <summary>
/// Used to calculate Model filling status in percentage
/// </summary>
/// <param name="modelState">Model state that contains information about filled fields</param>
/// <param name="prefix">Prefix that used to get full path to elemet returned from page</param>
public int GetProgressPercentage(ModelStateDictionary modelState, string prefix)
{
var successCnt = 0;
var errorCnt = 0;
var formattedList = this.GetAllPropertyFormattedList(this).Select(s => prefix + s).ToList();
foreach (var element in formattedList)
{
if (modelState.ContainsKey(element))
{
if (modelState[element].Errors.Count == 0)
{
if (!string.IsNullOrEmpty(modelState[element].Value.AttemptedValue))
{
successCnt++;
}
}
else
{
errorCnt++;
}
}
}
var totalCnt = successCnt + errorCnt;
return totalCnt == 0 ? 100 : (successCnt * 100 / totalCnt);
}
public async Task ReadAsync_WhenSuppressJsonDeserializationExceptionMessagesIsTrue_DoesNotWrapJsonInputExceptions()
{
// Arrange
var logger = GetLogger();
var formatter = new JsonInputFormatter(
logger, _serializerSettings, ArrayPool <char> .Shared, _objectPoolProvider,
suppressInputFormatterBuffering: false, suppressJsonDeserializationExceptionMessages: true);
var contentBytes = Encoding.UTF8.GetBytes("{");
var modelStateKey = string.Empty;
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.True(!modelState.IsValid);
Assert.True(modelState.ContainsKey(modelStateKey));
var modelError = modelState[modelStateKey].Errors.Single();
Assert.IsNotType <InputFormatterException>(modelError.Exception);
Assert.Empty(modelError.ErrorMessage);
}
/// <summary>
/// Stores the errors in a ValidationResult object to the specified modelstate dictionary.
/// </summary>
/// <param name="result">The validation result to store</param>
/// <param name="modelState">The ModelStateDictionary to store the errors in.</param>
/// <param name="prefix">An optional prefix. If ommitted, the property names will be the keys. If specified, the prefix will be concatenatd to the property name with a period. Eg "user.Name"</param>
public static void AddToModelState(this ValidationResult result, ModelStateDictionary modelState, string prefix)
{
if (!result.IsValid)
{
foreach (var error in result.Errors)
{
string key = string.IsNullOrEmpty(prefix)
? error.PropertyName
: string.IsNullOrEmpty(error.PropertyName)
? prefix
: prefix + "." + error.PropertyName;
if (modelState.ContainsKey(key))
{
modelState[key].Errors.Add(error.ErrorMessage);
}
else
{
modelState.AddModelError(key, error.ErrorMessage);
//To work around an issue with MVC: SetModelValue must be called if AddModelError is called.
modelState.SetModelValue(key, new ValueProviderResult(error.AttemptedValue ?? "", (error.AttemptedValue ?? "").ToString(), CultureInfo.CurrentCulture));
}
}
}
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var logger = GetLogger();
var formatter = new JsonInputFormatter(logger);
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
modelState.MaxAllowedErrors = 3;
modelState.AddModelError("key1", "error1");
modelState.AddModelError("key2", "error2");
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.ContainsKey("age"));
var error = Assert.Single(modelState[""].Errors);
Assert.IsType <TooManyModelErrorsException>(error.Exception);
}
private void CopyTempDataToModelState(ModelStateDictionary modelState,
TempDataDictionary tempData)
{
if (!tempData.ContainsKey(TempDataKey))
{
return;
}
ModelStateDictionary fromTempData = tempData[TempDataKey]
as ModelStateDictionary;
if (fromTempData == null)
{
return;
}
foreach (KeyValuePair<string, ModelState> pair in fromTempData)
{
if (modelState.ContainsKey(pair.Key))
{
modelState[pair.Key].Value = pair.Value.Value;
foreach (ModelError error in pair.Value.Errors)
{
modelState[pair.Key].Errors.Add(error);
}
}
else
{
modelState.Add(pair.Key, pair.Value);
}
}
}
private void AddErrorsToModel(IdentityResult identityResult, ModelStateDictionary modelState)
{
foreach (var currentError in identityResult.Errors)
{
string currentKey = string.Empty;
if (currentError.Code.Contains("Email"))
{
currentKey = $"Email";
}
else if (currentError.Code.Contains("Password"))
{
currentKey = $"password";
}
else
{
currentKey = $"UserName";
}
if (modelState.ContainsKey(currentKey))
{
if (modelState[currentKey].Errors.Count == 0)
{
modelState.AddModelError(currentKey, currentError.Description);
}
}
}
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(httpContext, modelState, typeof(User));
modelState.MaxAllowedErrors = 3;
modelState.AddModelError("key1", "error1");
modelState.AddModelError("key2", "error2");
// Act
var model = await formatter.ReadAsync(context);
// Assert
Assert.False(modelState.ContainsKey("age"));
var error = Assert.Single(modelState[""].Errors);
Assert.IsType <TooManyModelErrorsException>(error.Exception);
}
private void CopyTempDataToModelState(ModelStateDictionary modelState, TempDataDictionary tempData)
{
if (!tempData.ContainsKey(TempDataKey))
{
return;
}
var fromTempData = tempData[TempDataKey] as ModelStateDictionary;
if (fromTempData == null)
{
return;
}
foreach (var pair in fromTempData)
{
if (modelState.ContainsKey(pair.Key))
{
modelState[pair.Key].Value = pair.Value.Value;
foreach (var error in pair.Value.Errors)
{
modelState[pair.Key].Errors.Add(error);
}
}
else
{
modelState.Add(pair.Key, pair.Value);
}
}
}
public static void ResetModelValue(this ModelStateDictionary modelStateDictionary, string key)
{
if (modelStateDictionary.ContainsKey(key))
{
modelStateDictionary.SetModelValue(key, new ValueProviderResult(null, null, null));
}
}
public async Task ReadAsync_RegistersJsonInputExceptionsAsInputFormatterException(
string content,
string modelStateKey,
string expectedMessage)
{
// Arrange
var logger = GetLogger();
var formatter =
new JsonInputFormatter(logger, _serializerSettings, ArrayPool <char> .Shared, _objectPoolProvider);
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.True(!modelState.IsValid);
Assert.True(modelState.ContainsKey(modelStateKey));
var modelError = modelState[modelStateKey].Errors.Single();
Assert.Equal(expectedMessage, modelError.ErrorMessage);
}
public static bool IsValidEditableFieldsOnly <T>(ModelStateDictionary modelState, T model)
{
var isValid = modelState.IsValid;
if (isValid)
{
return(true);
}
//If it is not valid, check if there are any errors
var props = typeof(T).GetProperties();
foreach (var propertyInfo in props)
{
if (modelState.ContainsKey(propertyInfo.Name) && modelState[propertyInfo.Name].Errors.Any() &&
ConditionMetForChangeVisually(propertyInfo, model, props))
{
//There were errors for this property, but it was not editable so remove them
modelState[propertyInfo.Name].Errors.Clear();
}
}
//re-evaluate validity after potentially having removed some errors
return(modelState.IsValid);
}
public static string GetErrorClass(this HtmlHelper htmlHelper, string propertyName, ModelStateDictionary modelState)
{
if (modelState.IsValid == false)
{
return(modelState.ContainsKey(propertyName) && modelState[propertyName].Errors.Count > 0 ? "govuk-form-group--error" : string.Empty);
}
return(string.Empty);
}
/// <summary>
/// Clears the validation messages and exceptions associated with a model property,
/// making the value in that property valid.
/// </summary>
/// <param name="modelState">ModelState object from which the model property will be removed, and thus be considered as valid.</param>
/// <param name="expression">Expression tree that goes to the property that should be made valid.</param>
public static void ClearPropertyErrors(this ModelStateDictionary modelState, Expression <Func <object> > expression)
{
var propertyInfo = MemberExpressionHelper.GetPropertyInfo(expression);
if (modelState.ContainsKey(propertyInfo.Name))
{
modelState[propertyInfo.Name].Errors.Clear();
}
}
public static ModelStateDictionary ClearError(this ModelStateDictionary m, string fieldName)
{
if (m.ContainsKey(fieldName))
{
m[fieldName].Errors.Clear();
m[fieldName].ValidationState = ModelValidationState.Valid;
}
return(m);
}
/// <summary>
///
/// </summary>
/// <param name="modelState"></param>
/// <param name="key"></param>
/// <returns></returns>
public static bool IsValid(this ModelStateDictionary modelState, string key)
{
if (modelState.ContainsKey(key))
{
return(modelState[key] !.ValidationState == ModelValidationState.Valid);
}
return(true);
}
public static void HasErrors(ModelStateDictionary dict, string key, params ModelError[] errors)
{
Assert.True(dict.ContainsKey(key));
var state = dict[key];
Assert.Equal(
// Tuples have an Equals override. ModelError doesn't :(
errors.Select(e => Tuple.Create(e.Exception, e.ErrorMessage)).ToArray(),
state.Errors.Select(e => Tuple.Create(e.Exception, e.ErrorMessage)).ToArray());
}
public static void HasErrors(ModelStateDictionary dict, string key, params ModelError[] errors)
{
Assert.True(dict.ContainsKey(key));
var state = dict[key];
Assert.Equal(
// Tuples have an Equals override. ModelError doesn't :(
errors.Select(e => Tuple.Create(e.Exception, e.ErrorMessage)).ToArray(),
state.Errors.Select(e => Tuple.Create(e.Exception, e.ErrorMessage)).ToArray());
}
private void RemoveModelStateError(ModelStateDictionary ModelState, string key)
{
if (!string.IsNullOrEmpty(key))
{
if (ModelState.ContainsKey(key))
{
ModelState[key].Errors.Clear();
}
}
}
private static void RemovePropertyState <TModel, TProperty>(HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression)
{
string text = ExpressionHelper.GetExpressionText(expression);
string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(text);
ModelStateDictionary modelState = htmlHelper.ViewContext.ViewData.ModelState;
if (modelState.ContainsKey(fullName))
{
modelState.Remove(fullName);
}
}
public void ShouldCopyAllErrorsWithPrefix()
{
// arrange
NameValueCollection nvc = new NameValueCollection();
nvc.Add("Email", "Invalid");
nvc.Add("Email", "Mising");
nvc.Add("Password", "Mising");
ValidationException ex = new ValidationException { Errors = nvc };
ModelStateDictionary modelState = new ModelStateDictionary();
// act
ex.ToModelErrors(modelState, "credentials");
// assert
Assert.IsFalse(modelState.ContainsKey("Email"));
Assert.IsFalse(modelState.ContainsKey("Password"));
Assert.AreEqual(2, modelState["credentials.Email"].Errors.Count);
Assert.AreEqual(1, modelState["credentials.Password"].Errors.Count);
}
public static void AddModelErrorSafety(this ModelStateDictionary errors, string key, string message)
{
if (errors.ContainsKey(key))
{
errors[key].Errors.Add(message);
}
else
{
errors.AddModelError(key, message);
}
}
public static void AddFirstToKey(this ModelStateDictionary controller, string key, string message)
{
if (!controller.ContainsKey(key))
{
controller.AddModelError(key, message);
}
else
{
controller[key].Errors.Insert(0, new ModelError(message));
}
}
private object GetValueFromModelState(ModelStateDictionary modelStateDictionary, string column)
{
if (modelStateDictionary.ContainsKey(column))
{
return(modelStateDictionary[column].Value.AttemptedValue);
}
else
{
return(DBNull.Value);
}
}
protected ModelValidationResult GetModelValidationResult(ModelStateDictionary modelState)
{
if (modelState.Count == 0)
{
return(new ModelValidationResult()
{
IsValid = true
});
}
var modelErrors = new List <IModelValidationError>();
if (modelState.ContainsKey(string.Empty))
{
modelErrors.AddRange(modelState[string.Empty].Errors.Select(x => new ModelValidationError(x.ErrorMessage)));
}
if (modelState.ContainsKey(WarningSpecialField))
{
modelErrors.AddRange(modelState[WarningSpecialField].Errors.Select(x => new ModelValidationError(x.ErrorMessage, true)));
}
var propertyErrors = new Dictionary <string, IEnumerable <IModelValidationError> >();
foreach (var modelError in modelState)
{
if (string.IsNullOrEmpty(modelError.Key) || WarningSpecialField == modelError.Key)
{
continue;
}
var list = new List <IModelValidationError>();
list.AddRange(modelError.Value.Errors.Select(x => new ModelValidationError(x.ErrorMessage)));
propertyErrors[modelError.Key] = list;
}
return(new ModelValidationResult()
{
IsValid = false,
ModelErrors = modelErrors,
PropertyErrors = propertyErrors
});
}
/// <summary>
/// Adds a generic culture error for use in displaying the culture validation error in the save/publish/etc... dialogs
/// </summary>
/// <param name="modelState"></param>
/// <param name="culture"></param>
/// <param name="segment"></param>
/// <param name="errMsg"></param>
internal static void AddVariantValidationError(this ModelStateDictionary modelState,
string culture, string segment, string errMsg)
{
var key = "_content_variant_" + (culture.IsNullOrWhiteSpace() ? "invariant" : culture) + "_" + (segment.IsNullOrWhiteSpace() ? "null" : segment) + "_";
if (modelState.ContainsKey(key))
{
return;
}
modelState.AddModelError(key, errMsg);
}
public void LogErrorAddsErrorToModelState()
{
ModelStateDictionary modelState = new ModelStateDictionary();
string prefix = "prefix";
IFormatterLogger formatterLogger = new ModelStateFormatterLogger(modelState, prefix);
formatterLogger.LogError("property", "error");
Assert.True(modelState.ContainsKey("prefix.property"));
Assert.Equal(1, modelState["prefix.property"].Errors.Count);
Assert.Equal("error", modelState["prefix.property"].Errors[0].ErrorMessage);
}
public void LogErrorAddsErrorToModelState()
{
ModelStateDictionary modelState = new ModelStateDictionary();
string prefix = "prefix";
IFormatterLogger formatterLogger = new ModelStateFormatterLogger(modelState, prefix);
formatterLogger.LogError("property", "error");
Assert.True(modelState.ContainsKey("prefix.property"));
Assert.Equal(1, modelState["prefix.property"].Errors.Count);
Assert.Equal("error", modelState["prefix.property"].Errors[0].ErrorMessage);
}
private void OnValidationError(string property, IReadOnlyCollection <ValidationFailure> errors, ModelStateDictionary modelState)
{
if (!modelState.ContainsKey(property))
{
modelState.Add(property, new ModelState());
}
ModelState modelStateErrors = modelState[property];
foreach (var failure in errors)
{
modelStateErrors.Errors.Add(failure.ErrorMessage);
}
}
public void will_consider_nocaptcha_invalid_when_response_is_missing()
{
var stubHttpContext = CreateHttpContext(noCaptchaChallenge: "1234");
var modelState = new ModelStateDictionary();
var attribute = new ValidateSpamPreventionAttribute();
attribute.Authorize(
stubHttpContext.Object,
modelState,
new Mock <ICaptchaValidator>().Object);
Assert.True(modelState.ContainsKey(Const.ModelStateKey));
}
public void will_add_a_model_state_error_when_both_the_nocaptcha_and_captcha_response_is_invalid()
{
var stubHttpContext = CreateHttpContext();
var modelState = new ModelStateDictionary();
var attribute = new ValidateSpamPreventionAttribute();
attribute.Authorize(
stubHttpContext.Object,
modelState,
new Mock <ICaptchaValidator>().Object);
Assert.True(modelState.ContainsKey(Const.ModelStateKey));
}
public void CreateUser_would_report_error_if_user_name_is_null_or_empty()
{
var modelError = new ModelStateDictionary();
_userAuthenticationServiceSUT.Create(null, _userName, modelError);
Assert.True(modelError.ContainsKey(UserAuthenticationService.PROP_USERNAME));
Assert.True(modelError.ContainsError(UserAuthenticationService.PROP_USERNAME, AccountString.UserNameCanNotBeNull));
}
public void MergeDoesNothingIfParameterIsNull()
{
// Arrange
ModelStateDictionary fooDict = new ModelStateDictionary() { { "foo", new ModelState() } };
// Act
fooDict.Merge(null);
// Assert
Assert.Single(fooDict);
Assert.True(fooDict.ContainsKey("foo"));
}
public void CreateUser_would_report_error_if_password_not_valid()
{
SetUpEmptyUserExpectationForNonExistingUser();
var modelError = new ModelStateDictionary();
_userAuthenticationServiceSUT.Create(new User { UserName = _nonExistignUserName, Password = "******" }, _userName, modelError);
Assert.True(modelError.ContainsKey(UserAuthenticationService.PROP_PASSWORD));
Assert.True(modelError.ContainsError(UserAuthenticationService.PROP_PASSWORD, AccountString.NotMatchPasswordRule));
}
public void ContainsKey_ReturnsFalse_IfNodeHasNotBeenMutated(string key)
{
// Arrange
var dictionary = new ModelStateDictionary();
dictionary.AddModelError("foo.bar", "some error");
// Act
var result = dictionary.ContainsKey(key);
// Assert
Assert.False(result);
}
public void ContainsKey_ReturnsTrue_IfNodeHasBeenMutated(string key)
{
// Arrange
var dictionary = new ModelStateDictionary();
dictionary.MarkFieldSkipped(key);
// Act
var result = dictionary.ContainsKey(key);
// Assert
Assert.True(result);
}
public void NullCheckFailedHandler_ModelStateAlreadyInvalid_DoesNothing()
{
// Arrange
var modelState = new ModelStateDictionary();
modelState.AddModelError("foo.bar", "Some existing error.");
var modelMetadata = GetMetadataForType(typeof(Person));
var validationNode = new ModelValidationNode(modelMetadata, "foo");
var validationContext = new ModelValidationContext(new DataAnnotationsModelMetadataProvider(),
Enumerable.Empty<IModelValidatorProvider>(),
modelState,
modelMetadata,
null);
var e = new ModelValidatedEventArgs(validationContext, parentNode: null);
// Act
var handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(modelMetadata, incomingValue: null);
handler(validationNode, e);
// Assert
Assert.False(modelState.ContainsKey("foo"));
}
public void NullCheckFailedHandler_ModelStateValid_AddsErrorString()
{
// Arrange
var modelState = new ModelStateDictionary();
var modelMetadata = GetMetadataForType(typeof(Person));
var validationNode = new ModelValidationNode(modelMetadata, "foo");
var validationContext = new ModelValidationContext(new DataAnnotationsModelMetadataProvider(),
Enumerable.Empty<IModelValidatorProvider>(),
modelState,
modelMetadata,
null);
var e = new ModelValidatedEventArgs(validationContext, parentNode: null);
// Act
var handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(modelMetadata, incomingValue: null);
handler(validationNode, e);
// Assert
Assert.True(modelState.ContainsKey("foo"));
Assert.Equal("A value is required.", modelState["foo"].Errors[0].ErrorMessage);
}
public void Should_add_to_modelstate_without_prefix()
{
var thing = new Thing();
var form = new FormCollection
{
{ "Age", "not a number" }
};
var modelState = new ModelStateDictionary();
try
{
validatingBinder.UpdateFrom(thing, form, modelState);
}
catch {}
finally
{
modelState.ContainsKey("Age").ShouldBeTrue();
}
}
public void MergeDoesNothingIfParameterIsNull()
{
// Arrange
var dictionary = new ModelStateDictionary() { { "foo", new ModelStateEntry() } };
// Act
dictionary.Merge(null);
// Assert
Assert.Single(dictionary);
Assert.True(dictionary.ContainsKey("foo"));
}
public void CreateUser_would_report_error_if_user_exist_already()
{
SetUpUserExpectationForExistingUser();
var modelError = new ModelStateDictionary();
_userAuthenticationServiceSUT.Create(new User { UserName = _userName }, _userName, modelError);
Assert.True(modelError.ContainsKey(UserAuthenticationService.PROP_USERNAME));
Assert.True(modelError.ContainsError(UserAuthenticationService.PROP_USERNAME, AccountString.UserAlreadyExist));
}
public void CreateUser_would_report_error_if_the_creator_has_no_rights()
{
SetUpEmptyUserExpectationForCreateNewAccountWithValidConditions();
var modelError = new ModelStateDictionary();
_userAuthenticationServiceSUT.Create(null, _nonExistignUserName, modelError);
Assert.True(modelError.ContainsKey(string.Empty));
Assert.True(modelError.ContainsError(string.Empty, AccountString.CreatorLackOfRight));
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var logger = GetLogger();
var formatter =
new JsonInputFormatter(logger, _serializerSettings, ArrayPool<char>.Shared, _objectPoolProvider);
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var provider = new EmptyModelMetadataProvider();
var metadata = provider.GetMetadataForType(typeof(User));
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
metadata: metadata,
readerFactory: new TestHttpRequestStreamReaderFactory().CreateReader);
modelState.MaxAllowedErrors = 3;
modelState.AddModelError("key1", "error1");
modelState.AddModelError("key2", "error2");
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.ContainsKey("age"));
var error = Assert.Single(modelState[""].Errors);
Assert.IsType<TooManyModelErrorsException>(error.Exception);
}
public void IsPasswordValidFalse()
{
var service = GetMockedUserService();
var modelState = new ModelStateDictionary();
var result = service.IsPasswordValid("12345", modelState);
Assert.False(result);
Assert.AreEqual(1, modelState.Count);
Assert.True(modelState.ContainsKey("Password"));
}
private void SetLogo(EditEventViewModel viewModel, ModelStateDictionary modelState)
{
bool hasLogo = Session[CurrentLogoKey] != null;
if(hasLogo)
{
viewModel.Logo = (byte[])Session[CurrentLogoKey];
viewModel.IsLogoSetted = true;
viewModel.HasLogo = true;
if(modelState.ContainsKey("HasLogo"))
modelState.Remove("HasLogo");
}
}
public async Task ReadAsync_UsesTryAddModelValidationErrorsToModelState()
{
// Arrange
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var formatter = new JsonInputFormatter();
var contentBytes = Encoding.UTF8.GetBytes(content);
var modelState = new ModelStateDictionary();
var httpContext = GetHttpContext(contentBytes);
var context = new InputFormatterContext(
httpContext,
modelName: string.Empty,
modelState: modelState,
modelType: typeof(User));
modelState.MaxAllowedErrors = 3;
modelState.AddModelError("key1", "error1");
modelState.AddModelError("key2", "error2");
// Act
var result = await formatter.ReadAsync(context);
// Assert
Assert.True(result.HasError);
Assert.False(modelState.ContainsKey("age"));
var error = Assert.Single(modelState[""].Errors);
Assert.IsType<TooManyModelErrorsException>(error.Exception);
}
public void ContainsKey_ReturnsFalse_IfNodeHasBeenRemoved(string key)
{
// Arrange
var dictionary = new ModelStateDictionary();
dictionary.AddModelError(key, "some error");
// Act
var remove = dictionary.Remove(key);
var containsKey = dictionary.ContainsKey(key);
// Assert
Assert.True(remove);
Assert.False(containsKey);
}
