public void ApplyCustomValidationSummaryOrdering_OneExtraRequested_ShouldIgnoreExtra()
{
var first = "First";
var second = "Second";
var third = "Third";
var missing = "Missing";
var firstPair = new KeyValuePair <string, ModelState>(first, null);
var secondPair = new KeyValuePair <string, ModelState>(second, null);
var thirdPair = new KeyValuePair <string, ModelState>(third, null);
var modelState = new ModelStateDictionary();
modelState.Add(thirdPair);
modelState.Add(secondPair);
modelState.Add(firstPair);
modelState.ApplyCustomValidationSummaryOrdering(new List <string> {
first, second, third, missing
});
Assert.Equal(3, modelState.Count);
Assert.Equal(firstPair, modelState.First());
Assert.Equal(secondPair, modelState.Skip(1).First());
Assert.Equal(thirdPair, modelState.Skip(2).First());
}
public void ApplyCustomValidationSummaryOrdering_AllRequested_ShouldOrderAsRequested()
{
var first = "First";
var second = "Second";
var third = "Third";
var last = "Last";
var firstPair = new KeyValuePair <string, ModelState>(first, null);
var secondPair = new KeyValuePair <string, ModelState>(second, null);
var thirdPair = new KeyValuePair <string, ModelState>(third, null);
var fourthPair = new KeyValuePair <string, ModelState>(last, null);
var modelState = new ModelStateDictionary();
modelState.Add(thirdPair);
modelState.Add(secondPair);
modelState.Add(fourthPair);
modelState.Add(firstPair);
modelState.ApplyCustomValidationSummaryOrdering(new List <string> {
first, second, third, last
});
Assert.Equal(4, modelState.Count);
Assert.Equal(firstPair, modelState.First());
Assert.Equal(secondPair, modelState.Skip(1).First());
Assert.Equal(thirdPair, modelState.Skip(2).First());
Assert.Equal(fourthPair, modelState.Last());
}
public void DictionaryType_ValidationSuccessful()
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0].Key", new ModelState());
modelStateDictionary.Add("items[0].Value", new ModelState());
modelStateDictionary.Add("items[1].Key", new ModelState());
modelStateDictionary.Add("items[1].Value", new ModelState());
var model = new Dictionary <string, string>()
{
{ "FooKey", "FooValue" },
{ "BarKey", "BarValue" }
};
var testValidationContext = GetModelValidationContext(
model,
typeof(Dictionary <string, string>),
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List <IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
testValidationContext.ExcludeFilters = excludeTypeFilters;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFilters,
testValidationContext.ModelMetadataProvider);
var topLevelValidationNode =
new ModelValidationNode(
"items",
testValidationContext.ModelValidationContext.ModelExplorer.Metadata,
testValidationContext.ModelValidationContext.ModelExplorer.Model)
{
ValidateAllProperties = true
};
// Act
validator.Validate(validationContext, topLevelValidationNode);
// Assert
Assert.True(validationContext.ModelState.IsValid);
Assert.Equal(4, validationContext.ModelState.Count);
var modelState = validationContext.ModelState["items[0].Key"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[0].Value"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[1].Key"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[1].Value"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
}
public void DictionaryType_ValidationSuccessful()
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0].Key", new ModelState());
modelStateDictionary.Add("items[0].Value", new ModelState());
modelStateDictionary.Add("items[1].Key", new ModelState());
modelStateDictionary.Add("items[1].Value", new ModelState());
var model = new Dictionary <string, string>()
{
{ "FooKey", "FooValue" },
{ "BarKey", "BarValue" }
};
var testValidationContext = GetModelValidationContext(
model,
typeof(Dictionary <string, string>),
"items",
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List <IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
var mockValidationExcludeFiltersProvider = new Mock <IValidationExcludeFiltersProvider>();
mockValidationExcludeFiltersProvider
.SetupGet(o => o.ExcludeFilters)
.Returns(excludeTypeFilters);
testValidationContext.ExcludeFiltersProvider = mockValidationExcludeFiltersProvider.Object;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFiltersProvider,
testValidationContext.ModelMetadataProvider);
// Act
validator.Validate(validationContext);
// Assert
Assert.True(validationContext.ModelState.IsValid);
var modelState = validationContext.ModelState["items"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
modelState = validationContext.ModelState["items[0].Key"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Skipped);
modelState = validationContext.ModelState["items[0].Value"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Skipped);
modelState = validationContext.ModelState["items[1].Key"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Skipped);
modelState = validationContext.ModelState["items[1].Value"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Skipped);
}
public void EnumerableType_ValidationSuccessful(object model, Type type)
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0]", new ModelState());
modelStateDictionary.Add("items[1]", new ModelState());
modelStateDictionary.Add("items[2]", new ModelState());
var testValidationContext = GetModelValidationContext(
model,
type,
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List <IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
testValidationContext.ExcludeFilters = excludeTypeFilters;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFilters,
testValidationContext.ModelMetadataProvider);
var topLevelValidationNode =
new ModelValidationNode(
"items",
testValidationContext.ModelValidationContext.ModelExplorer.Metadata,
testValidationContext.ModelValidationContext.ModelExplorer.Model)
{
ValidateAllProperties = true
};
// Act
validator.Validate(validationContext, topLevelValidationNode);
// Assert
Assert.True(validationContext.ModelState.IsValid);
Assert.Equal(3, validationContext.ModelState.Count);
var modelState = validationContext.ModelState["items[0]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
modelState = validationContext.ModelState["items[1]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
modelState = validationContext.ModelState["items[2]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
}
public void ValidateSum(double sum, double minSum, double maxSum, ModelStateDictionary modelState, bool isInitial = false)
{
if (sum < minSum)
{
modelState.Add(isInitial ? "request.InitialSum" : "request.Sum",
new ModelState() {Errors = {"—умма не может быть меньше минимальной."}});
}
if (sum > maxSum)
{
modelState.Add(isInitial ? "request.InitialSum" : "request.Sum", new ModelState() { Errors = { "—умма не может быть больше максимальной." } });
// throw BankClientException.ThrowSumMoreThanMax();
}
}
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));
}
public void element_without_error_renders_with_attempted_value()
{
stateDictionary.Add("Price", new ModelState()
{
Value = new ValueProviderResult("foo", "foo", CultureInfo.CurrentCulture)
});
expression = x => x.Price;
var textbox = new TextBox(expression.GetNameFor(), expression.GetMemberExpression(), new List <IBehaviorMarker> {
target
});
var element = textbox.ToString().ShouldHaveHtmlNode("Price");
element.ShouldHaveAttribute(HtmlAttribute.Value).WithValue("foo");
}
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 ModelState());
modelState.Add("items[0].Value", new ModelState());
modelState.Add("items[1].Key", new ModelState());
modelState.Add("items[1].Value", new ModelState());
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);
}
/// <summary>
/// Overrides default OnActionExecuted method.
/// </summary>
/// <param name="filterContext">The filter context.</param>
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
//// Support for HtmlHelperExtensions.NamedValidationSummary().
filterContext.Controller.ViewData[HtmlHelperExtensions.SubmittedFormName] = filterContext.Controller.TempData[HtmlHelperExtensions.SubmittedFormName];
var modelState = filterContext.Controller.TempData[ModelStateTempDataTransferAttribute.Key] as ModelStateDictionary;
if (modelState != null)
{
// Only Import if we are viewing
if (filterContext.Result is ViewResult)
{
if (this.ImportJustInvalidStates)
{
var invalidModelStates = new ModelStateDictionary();
foreach (var ms in modelState.Where(x => x.Value.Errors.Any()))
{
invalidModelStates.Add(ms);
}
modelState = invalidModelStates;
}
filterContext.Controller.ViewData.ModelState.Merge(modelState);
}
else
{
// Otherwise remove it.
filterContext.Controller.TempData.Remove(ModelStateTempDataTransferAttribute.Key);
}
}
base.OnActionExecuted(filterContext);
}
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 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);
}
}
}
private static ModelStateDictionary ValidateObject(object value)
{
var modelState = new ModelStateDictionary();
var objectProperties = value.GetType().GetProperties();
foreach (var objectProperty in objectProperties)
{
var validationAttributes = objectProperty
.GetCustomAttributes()
.Where(type => type is ValidationSisAttribute)
.Cast <ValidationSisAttribute>()
.ToList();
foreach (var validationAttribute in validationAttributes)
{
if (validationAttribute.IsValid(objectProperty.GetValue(value)))
{
continue;
}
modelState.Add(objectProperty.Name, validationAttribute.ErrorMessage);
}
}
return(modelState);
}
public void AddErrors(ModelStateDictionary modelState)
{
foreach (var state in modelState)
{
ModelState.Add(state);
}
}
public void Errors_FromModelState()
{
modelState.AddModelError("Empty", "");
modelState.AddModelError("Error", "Error");
modelState.AddModelError("EmptyErrors", "");
modelState.AddModelError("EmptyErrors", "E");
modelState.Add("NoErrors", new ModelState());
modelState.AddModelError("TwoErrors", "Error1");
modelState.AddModelError("TwoErrors", "Error2");
modelState.AddModelError("NullError", (String)null);
modelState.AddModelError("NullErrors", (String)null);
modelState.AddModelError("NullErrors", "NotNullError");
modelState.AddModelError("WhitespaceErrors", " ");
modelState.AddModelError("WhitespaceErrors", "Whitespace");
Dictionary <String, String> actual = modelState.Errors();
Assert.Equal(" ", actual["WhitespaceErrors"]);
Assert.Equal("NotNullError", actual["NullErrors"]);
Assert.Equal("Error1", actual["TwoErrors"]);
Assert.Equal("E", actual["EmptyErrors"]);
Assert.Equal("Error", actual["Error"]);
Assert.Null(actual["NullError"]);
Assert.Equal(7, actual.Count);
Assert.Null(actual["Empty"]);
}
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);
}
}
}
private void ValidateListModelState <T>(List <T> consoles) where T : GameConsole
{
var dictinory = new ModelStateDictionary();
for (int entityPosition = 0; entityPosition < consoles.Count; entityPosition++)
{
TryValidateModel(consoles[entityPosition]);
for (int i = 0; i < ModelState.Keys.Count; i++)
{
dictinory.Add($"[{entityPosition}].{ModelState.Keys.ToList()[i]}", ModelState.Values.ToList()[i]);
}
var entityStateDictionary = consoles[entityPosition].State;
entityStateDictionary.ToList().ForEach(x =>
{
dictinory.AddModelError($"[{entityPosition}].{x.Key}", x.Value);
});
ModelState.Clear();
}
for (int i = 0; i < dictinory.Keys.Count; i++)
{
ModelState.Add(dictinory.Keys.ToList()[i], dictinory.Values.ToList()[i]);
}
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
ControllerBase controller = filterContext.Controller as ControllerBase;
if (controller != null)
{
string serializedModelState = controller.TempData[Key] as string;
if (!string.IsNullOrEmpty(serializedModelState))
{
IEnumerable<ModelStateWrapper> modelStateWrappers = JsonConvert.DeserializeObject<IEnumerable<ModelStateWrapper>>(serializedModelState, new JsonSerializerSettings() { Error = DeserializationErrorHandler });
if (modelStateWrappers != null)
{
ModelStateDictionary modelState = new ModelStateDictionary();
foreach (ModelStateWrapper modelStateWrapper in modelStateWrappers)
{
ModelState ms = new ModelState();
ms.ValidationState = modelStateWrapper.ValidationState;
ms.Value = new ValueProviderResult(modelStateWrapper.Value, modelStateWrapper.Value, null);
modelState.Add(modelStateWrapper.Key, ms);
}
if (filterContext.Result is ViewResult)
controller.ViewData.ModelState.Merge(modelState);
else controller.TempData.Remove(Key);
}
}
}
base.OnActionExecuted(filterContext);
}
private static ModelStateDictionary ValidateObject(object value)
{
ModelStateDictionary modelStateDictionary = new ModelStateDictionary();
var objectProperties = value.GetType().GetProperties();
foreach (var prop in objectProperties)
{
var validationAttributes = prop.GetCustomAttributes()
.Where(attribute => attribute is BaseValidationAttribute)
.Cast <BaseValidationAttribute>()
.ToList();
foreach (var validationAttribure in validationAttributes)
{
if (validationAttribure.IsValid(prop.GetValue(value)))
{
continue;
}
modelStateDictionary.Add(prop.Name, validationAttribure.ErrorMessage);
}
}
return(modelStateDictionary);
}
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);
}
}
}
/// <summary>
/// Home which is the main landing page.
/// </summary>
//[Menu("Home")]
// OutputCache not working in environment
// http://stackoverflow.com/questions/5371773/asp-net-mvc-outputcache-vary-by-and-vary-by-user-cookie
// http://blogs.msdn.com/b/tmarq/archive/2008/08/27/using-iis-7-0-dynamic-compression-with-asp-net-output-cache.aspx
//[OutputCache(Duration = 60, VaryByParam = "*", VaryByCustom = "user", Location = OutputCacheLocation.Client)]
public ActionResult Index()
{
PageTitle = "Home";
// Only show noticeboard messages if the user has a Diary role
var viewModel = new IndexViewModel {
ShowNoticeboardMessages = false
}; //UserService.IsInRole(new [] { "DIA", "DIU", "DIV" })
if (viewModel.ShowNoticeboardMessages)
{
try
{
viewModel.NoticeboardMessages = NoticeboardService.GetSpecificMessages(UserService.SiteCode, UserService.DateTime).ToMessageViewModelList(); // MappingEngine.Map<IEnumerable<MessageViewModel>>(NoticeboardService.GetSpecificMessages(UserService.SiteCode, UserService.DateTime));
}
catch (ServiceValidationException se)
{
ModelStateDictionary modelStateDictionary = new ModelStateDictionary();
foreach (var item in se.Errors)
{
var modelState = new ModelState();
modelState.Value = new ValueProviderResult(item.Value, item.Value, System.Globalization.CultureInfo.InvariantCulture);
modelStateDictionary.Add(new KeyValuePair <string, ModelState>(item.Key, modelState));
}
ModelState.Merge(modelStateDictionary);
}
}
return(View(viewModel));
}
public void DoesNotAddEntries_IfNoErrorsArePresent()
{
// Arrange
var modelState = new ModelStateDictionary();
modelState.Add(
"key1",
new ModelState() { Value = new ValueProviderResult("foo", "foo", CultureInfo.InvariantCulture) });
modelState.Add(
"key2",
new ModelState() { Value = new ValueProviderResult("bar", "bar", CultureInfo.InvariantCulture) });
// Act
var serializableError = new SerializableError(modelState);
// Assert
Assert.Equal(0, serializableError.Count);
}
public void DoesNotAddEntries_IfNoErrorsArePresent()
{
// Arrange
var modelState = new ModelStateDictionary();
modelState.Add(
"key1",
new ModelStateEntry());
modelState.Add(
"key2",
new ModelStateEntry());
// Act
var serializableError = new SerializableError(modelState);
// Assert
Assert.Equal(0, serializableError.Count);
}
/// <summary>
/// Add an element that has the specified key and the value to the model-state dictionary
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <param name="modelStateDictionary">The model state dictionary.</param>
/// <param name="expression">The expression tree representing a property to add an error in its state.</param>
/// <param name="value">The value of the element to add.</param>
public static void Add <TModel>(this ModelStateDictionary modelStateDictionary, Expression <Func <TModel, object> > expression, ModelState value)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
modelStateDictionary.Add(ExpressionHelper.GetExpressionText(expression), value);
}
public void Should_skip_properties_without_errors()
{
var msd = new ModelStateDictionary();
msd.Add("item.Property1", new ModelState());
msd.AddModelError("item.Property2", "Error");
ValidationHelpers.PropertyError pe = ValidationHelpers.MakeHierarchical(msd);
Assert.That(pe["item"].Properties.Count, Is.EqualTo(1));
}
public IHttpActionResult GetBadRequestWithModelState()
{
ModelStateDictionary dic = new ModelStateDictionary();
dic.Add("a", ModelState["abc"]);
dic.AddModelError("err", "hello");
return(BadRequest(dic));
}
public void DoesNotAddEntries_IfNoErrorsArePresent()
{
// Arrange
var modelState = new ModelStateDictionary();
modelState.Add(
"key1",
new ModelStateEntry());
modelState.Add(
"key2",
new ModelStateEntry());
// Act
var serializableError = new SerializableError(modelState);
// Assert
Assert.Equal(0, serializableError.Count);
}
public void ValidateMonthCount(int monthCount, int minMonthPeriod, int maxMonthPeriod, ModelStateDictionary modelState)
{
if (monthCount < minMonthPeriod)
{
modelState.Add("request.MonthCount", new ModelState()
{
Errors = { " оличество мес¤цев не может быть меньше минимального." }
});
// throw BankClientException.ThrowMonthLessThanMin();
}
if (monthCount > maxMonthPeriod)
{
modelState.Add("request.MonthCount", new ModelState()
{
Errors = { " оличество мес¤цев не может быть больше максимального." }
});
}
}
public static void CopyRelevantNonEmptyErrors(ModelStateDictionary destination, ModelStateDictionary origin, string prefix)
{
foreach (KeyValuePair <string, ModelState> pair in origin)
{
if (pair.Key.StartsWith(prefix) && pair.Value.Errors.Count > 0)
{
destination.Add(pair);
}
}
}
public void EnumerableType_ValidationSuccessful(object model, Type type)
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0]", new ModelState());
modelStateDictionary.Add("items[1]", new ModelState());
modelStateDictionary.Add("items[2]", new ModelState());
var testValidationContext = GetModelValidationContext(
model,
type,
"items",
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List <IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
var mockValidationExcludeFiltersProvider = new Mock <IValidationExcludeFiltersProvider>();
mockValidationExcludeFiltersProvider
.SetupGet(o => o.ExcludeFilters)
.Returns(excludeTypeFilters);
testValidationContext.ExcludeFiltersProvider = mockValidationExcludeFiltersProvider.Object;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFiltersProvider,
testValidationContext.ModelMetadataProvider);
// Act
validator.Validate(validationContext);
// Assert
Assert.True(validationContext.ModelState.IsValid);
var modelState = validationContext.ModelState["items"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
}
public void ValidateSum(double sum, double minSum, double maxSum, ModelStateDictionary modelState, bool isInitial = false)
{
if (sum < minSum)
{
modelState.Add(isInitial ? "request.InitialSum" : "request.Sum",
new ModelState()
{
Errors = { "—умма не может быть меньше минимальной." }
});
}
if (sum > maxSum)
{
modelState.Add(isInitial ? "request.InitialSum" : "request.Sum", new ModelState()
{
Errors = { "—умма не может быть больше максимальной." }
});
// throw BankClientException.ThrowSumMoreThanMax();
}
}
public void Should_convert_model_state_exception_to_text()
{
var modelState = new ModelStateDictionary();
var ms1 = new ModelState();
ms1.Errors.Add(new Exception("v1"));
ms1.Errors.Add(new Exception("v2"));
modelState.Add("k", ms1);
var ms2 = new ModelState();
ms2.Errors.Add(new Exception("v3"));
ms2.Errors.Add(new Exception("v4"));
modelState.Add("k1", ms2);
var actual = modelState.GetModelStateErrors();
Assert.Equal("\"v1\", \"v2\", \"v3\", \"v4\"", actual);
}
public void GivenAnErrorWhenAddingAComment_WhenIGetThePostWithTheComment_ThenTheViewDataIsUpdateWithTheError()
{
var controller = new PostController(_postServiceMock.Object, _dashboardServiceMock, _blogService.Object, null);
var tempData = new ModelStateDictionary();
tempData.Add("key", new ModelState());
controller.TempData["comment"] = tempData;
controller.Show(new PostLinkViewModel());
Assert.That(controller.ViewData, Is.Not.Null);
Assert.That(controller.ViewData.ModelState, Is.Not.Null);
Assert.That(controller.ViewData.ModelState["key"], Is.Not.Null);
}
public void ModelErrorWithExceptionIntoJson()
{
var modelState = new ModelStateDictionary();
modelState.Add("FirstName", new ModelState { Errors = { new InvalidOperationException("Cannot operate") } });
var jsonResult = ControllerExtensions.ToJson(modelState);
var data = jsonResult.Data;
Assert.That(data, Has.Property("State").Not.Empty);
Assert.That(data, Has.Property("State").With.Some.Property("Name").EqualTo("FirstName"));
Assert.That(data, Has.Property("State").With.Some.Property("Errors").With.Some.EqualTo("Cannot operate"));
}
public void SimpleModelErrorIntoJson()
{
var modelState = new ModelStateDictionary();
modelState.Add("FirstName", new ModelState { Errors = { "First name is a required field" } });
var jsonResult = ControllerExtensions.ToJson(modelState);
var data = jsonResult.Data;
Assert.That(data, Has.Property("State").Not.Empty);
Assert.That(data, Has.Property("State").With.Some.Property("Name").EqualTo("FirstName"));
Assert.That(data, Has.Property("State").With.Some.Property("Errors").With.Some.EqualTo("First name is a required field"));
}
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 ModelState());
modelState.Add("items[1]", new ModelState());
modelState.Add("items[2]", new ModelState());
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);
}
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 static void ApplyCustomValidationSummaryOrdering(this ModelStateDictionary modelState, IEnumerable <string> modelStateKeys)
{
var result = new ModelStateDictionary();
foreach (string key in modelStateKeys)
{
if (modelState.ContainsKey(key) && !result.ContainsKey(key))
{
result.Add(key, modelState[key]);
}
}
foreach (string key in modelState.Keys)
{
if (!result.ContainsKey(key))
{
result.Add(key, modelState[key]);
}
}
modelState.Clear();
modelState.Merge(result);
}
/// <summary>
/// Gets the warnings.
/// </summary>
/// <param name="modelStateDictionary">The model state dictionary.</param>
/// <returns></returns>
public static ModelStateDictionary GetWarnings(this ModelStateDictionary modelStateDictionary)
{
var msd = new ModelStateDictionary();
foreach (var ms in from ms in modelStateDictionary
let extendedModelState = ms.Value as ExtendedModelState
where extendedModelState != null
where extendedModelState.Warnings.Count != 0
select ms)
{
msd.Add(ms);
}
return(msd);
}
public void DoesNotAddEntries_IfNoErrorsArePresent()
{
// Arrange
var modelState = new ModelStateDictionary();
modelState.Add(
"key1",
new ModelState()
{
Value = new ValueProviderResult("foo", "foo", CultureInfo.InvariantCulture)
});
modelState.Add(
"key2",
new ModelState()
{
Value = new ValueProviderResult("bar", "bar", CultureInfo.InvariantCulture)
});
// Act
var serializableError = new SerializableError(modelState);
// Assert
Assert.Equal(0, serializableError.Count);
}
public void Does_Not_Overwrite_Any_Existing_ModelState_Value()
{
// Arrange
object rawValue = new object();
var someValue = new ModelState { Value = new ValueProviderResult(rawValue, null, null)};
var ex = new RulesException("myProp", "myError");
var modelState = new ModelStateDictionary();
modelState.Add("myProp", someValue);
// Act
ex.AddModelStateErrors(modelState, null);
// Assert
Assert.Equal(1, modelState.Keys.Count());
Assert.Same(rawValue, modelState["myProp"].Value.RawValue);
}
public void ReturnsCorrectly()
{
string key = "Key";
string value = "Value";
var modelState = new ModelState();
modelState.Value = new ValueProviderResult( value, value, CultureInfo.InvariantCulture );
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add( key, modelState );
ModelState modelStateResult;
var result = modelStateDictionary.GetModelStateValue( key, value.GetType(), out modelStateResult );
Assert.AreEqual( result, value );
Assert.AreSame( modelStateResult, modelState );
}
public void WithKeyNotFoundReturnsCorrectly()
{
string key = "Key";
string value = "Value";
var modelState = new ModelState();
modelState.Value = new ValueProviderResult( value, value, CultureInfo.InvariantCulture );
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add( key, modelState );
ModelState modelStateResult;
var result = modelStateDictionary.GetModelStateValue( "KeyNotFound", typeof( string ), out modelStateResult );
Assert.IsNull( result );
Assert.IsNull( modelStateResult );
}
private static void CreateModelValidationNodeRecursive(object o, ModelValidationNode parentNode, ModelMetadataProvider metadataProvider, ModelMetadata metadata, ModelStateDictionary modelStateDictionary, string modelStateKey, HashSet<object> visited)
{
if (visited.Contains(o))
{
return;
}
visited.Add(o);
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(o))
{
// append the current property name to the model state path
string propertyKey = modelStateKey;
if (propertyKey.Length > 0)
{
propertyKey += ".";
}
propertyKey += property.Name;
// create the node for this property and add to the parent node
object propertyValue = property.GetValue(o);
metadata = metadataProvider.GetMetadataForProperty(() =>
{
return propertyValue;
}, o.GetType(), property.Name);
ModelValidationNode childNode = new ModelValidationNode(metadata, propertyKey);
parentNode.ChildNodes.Add(childNode);
// add the property node to model state
ModelState modelState = new ModelState();
modelState.Value = new ValueProviderResult(propertyValue, null, CultureInfo.CurrentCulture);
modelStateDictionary.Add(propertyKey, modelState);
if (propertyValue != null)
{
CreateModelValidationNodeRecursive(propertyValue, childNode, metadataProvider, metadata, modelStateDictionary, propertyKey, visited);
}
}
}
public void RemoveAll_ForSingleExpression_RemovesModelStateKeys()
{
// Arrange
var state = new ModelState();
var dictionary = new ModelStateDictionary();
dictionary.Add("Key", state);
dictionary.Add("Text", new ModelState());
dictionary.Add("Text.Length", new ModelState());
// Act
dictionary.RemoveAll<TestModel>(model => model.Text);
// Assert
var modelState = Assert.Single(dictionary);
Assert.Equal("Key", modelState.Key);
Assert.Same(state, modelState.Value);
}
public void DictionaryType_ValidationSuccessful()
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0].Key", new ModelState());
modelStateDictionary.Add("items[0].Value", new ModelState());
modelStateDictionary.Add("items[1].Key", new ModelState());
modelStateDictionary.Add("items[1].Value", new ModelState());
var model = new Dictionary<string, string>()
{
{ "FooKey", "FooValue" },
{ "BarKey", "BarValue" }
};
var testValidationContext = GetModelValidationContext(
model,
typeof(Dictionary<string, string>),
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List<IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
testValidationContext.ExcludeFilters = excludeTypeFilters;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFilters,
testValidationContext.ModelMetadataProvider);
var topLevelValidationNode =
new ModelValidationNode(
"items",
testValidationContext.ModelValidationContext.ModelExplorer.Metadata,
testValidationContext.ModelValidationContext.ModelExplorer.Model)
{
ValidateAllProperties = true
};
// Act
validator.Validate(validationContext, topLevelValidationNode);
// Assert
Assert.True(validationContext.ModelState.IsValid);
Assert.Equal(4, validationContext.ModelState.Count);
var modelState = validationContext.ModelState["items[0].Key"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[0].Value"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[1].Key"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
modelState = validationContext.ModelState["items[1].Value"];
Assert.Equal(ModelValidationState.Skipped, modelState.ValidationState);
}
public void EnumerableType_ValidationSuccessful(object model, Type type)
{
// Arrange
var modelStateDictionary = new ModelStateDictionary();
modelStateDictionary.Add("items[0]", new ModelState());
modelStateDictionary.Add("items[1]", new ModelState());
modelStateDictionary.Add("items[2]", new ModelState());
var testValidationContext = GetModelValidationContext(
model,
type,
excludedTypes: null,
modelStateDictionary: modelStateDictionary);
var excludeTypeFilters = new List<IExcludeTypeValidationFilter>();
excludeTypeFilters.Add(new SimpleTypesExcludeFilter());
testValidationContext.ExcludeFilters = excludeTypeFilters;
var validationContext = testValidationContext.ModelValidationContext;
var validator = new DefaultObjectValidator(
testValidationContext.ExcludeFilters,
testValidationContext.ModelMetadataProvider);
var topLevelValidationNode =
new ModelValidationNode(
"items",
testValidationContext.ModelValidationContext.ModelExplorer.Metadata,
testValidationContext.ModelValidationContext.ModelExplorer.Model)
{
ValidateAllProperties = true
};
// Act
validator.Validate(validationContext, topLevelValidationNode);
// Assert
Assert.True(validationContext.ModelState.IsValid);
Assert.Equal(3, validationContext.ModelState.Count);
var modelState = validationContext.ModelState["items[0]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
modelState = validationContext.ModelState["items[1]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
modelState = validationContext.ModelState["items[2]"];
Assert.Equal(modelState.ValidationState, ModelValidationState.Valid);
}
public void ModelStatePropertyGetterWorks()
{
// Arrange
ApiController controller = new Mock<ApiController>().Object;
// Act
ModelStateDictionary expected = new ModelStateDictionary();
expected.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });
controller.ModelState.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });
// Assert
Assert.Equal(expected.Count, controller.ModelState.Count);
}
public void Remove_ForRelationExpression_RemovesModelStateKey()
{
// Arrange
var dictionary = new ModelStateDictionary();
dictionary.Add("Child.Text", new ModelStateEntry());
// Act
dictionary.Remove<TestModel>(model => model.Child.Text);
// Assert
Assert.Empty(dictionary);
}
public void Remove_ForNotModelsExpression_RemovesModelStateKey()
{
// Arrange
var variable = "Test";
var dictionary = new ModelStateDictionary();
dictionary.Add("variable", new ModelStateEntry());
// Act
dictionary.Remove<TestModel>(model => variable);
// Assert
Assert.Empty(dictionary);
}
public void Remove_ForImplicitlyCastedToObjectExpression_RemovesModelStateKey()
{
// Arrange
var dictionary = new ModelStateDictionary();
dictionary.Add("Child.Value", new ModelStateEntry());
// Act
dictionary.Remove<TestModel>(model => model.Child.Value);
// Assert
Assert.Empty(dictionary);
}
public void RemoveAll_ForImplicitlyCastedToObjectExpression_RemovesModelStateKeys()
{
// Arrange
var state = new ModelStateEntry();
var dictionary = new ModelStateDictionary();
dictionary.Add("Child", state);
dictionary.Add("Child.Value", new ModelStateEntry());
// Act
dictionary.RemoveAll<TestModel>(model => model.Child.Value);
// Assert
var modelState = Assert.Single(dictionary);
Assert.Equal("Child", modelState.Key);
Assert.Same(state, modelState.Value);
}
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_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 RemoveAll_ForNotModelsExpression_RemovesModelStateKeys()
{
// Arrange
var variable = "Test";
var state = new ModelStateEntry();
var dictionary = new ModelStateDictionary();
dictionary.Add("Key", state);
dictionary.Add("variable", new ModelStateEntry());
dictionary.Add("variable.Text", new ModelStateEntry());
dictionary.Add("variable.Value", new ModelStateEntry());
// Act
dictionary.RemoveAll<TestModel>(model => variable);
// Assert
var modelState = Assert.Single(dictionary);
Assert.Equal("Key", modelState.Key);
Assert.Same(state, modelState.Value);
}
public void RemoveAll_ForModelExpression_RemovesModelPropertyKeys()
{
// Arrange
var state = new ModelStateEntry();
var dictionary = new ModelStateDictionary();
dictionary.Add("Key", state);
dictionary.Add("Text", new ModelStateEntry());
dictionary.Add("Child", new ModelStateEntry());
dictionary.Add("Child.Text", new ModelStateEntry());
dictionary.Add("Child.NoValue", new ModelStateEntry());
// Act
dictionary.RemoveAll<TestModel>(model => model);
// Assert
var modelState = Assert.Single(dictionary);
Assert.Equal("Key", modelState.Key);
Assert.Same(state, modelState.Value);
}
public void ValidateMonthCount(int monthCount, int minMonthPeriod, int maxMonthPeriod, ModelStateDictionary modelState)
{
if (monthCount < minMonthPeriod)
{
modelState.Add("request.MonthCount", new ModelState() { Errors = { " оличество мес¤цев не может быть меньше минимального." } });
// throw BankClientException.ThrowMonthLessThanMin();
}
if (monthCount > maxMonthPeriod)
{
modelState.Add("request.MonthCount", new ModelState() { Errors = { " оличество мес¤цев не может быть больше максимального." } });
}
}
