private static DefaultModelBindingContext GetModelBindingContext(
IValueProvider valueProvider,
bool isReadOnly = false)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty <ModelWithIListProperty>(nameof(ModelWithIListProperty.ListProperty))
.BindingDetails(bd => bd.IsReadOnly = isReadOnly);
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithIListProperty),
nameof(ModelWithIListProperty.ListProperty));
var bindingContext = new DefaultModelBindingContext
{
ModelMetadata = metadata,
ModelName = "someName",
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider,
OperationBindingContext = new OperationBindingContext
{
ModelBinder = CreateIntBinder(),
MetadataProvider = metadataProvider
},
ValidationState = new ValidationStateDictionary(),
FieldName = "testfieldname",
};
return(bindingContext);
}
public void EnterNestedScope_FiltersValueProviders_BasedOnTopLevelValueProviders()
{
// Arrange
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty(typeof(string), nameof(string.Length))
.BindingDetails(b => b.BindingSource = BindingSource.Form);
var original = CreateDefaultValueProvider();
var operationBindingContext = new OperationBindingContext()
{
ActionContext = new ActionContext(),
ValueProvider = original,
};
var context = DefaultModelBindingContext.CreateBindingContext(
operationBindingContext,
metadataProvider.GetMetadataForType(typeof(string)),
new BindingInfo()
{
BindingSource = BindingSource.Query
},
"model");
var propertyMetadata = metadataProvider.GetMetadataForProperty(typeof(string), nameof(string.Length));
// Act
context.EnterNestedScope(propertyMetadata, "Length", "Length", model: null);
// Assert
Assert.Collection(
Assert.IsType <CompositeValueProvider>(context.ValueProvider),
vp => Assert.Same(original[2], vp));
}
public async Task BindModelAsync_ForProperty_UsesValidationOnProperty_WhenDerivedModelIsSet()
{
// Arrange
var property = typeof(TestControllerWithValidatedProperties).GetProperty(nameof(TestControllerWithValidatedProperties.Model));
var parameterDescriptor = new ControllerBoundPropertyDescriptor
{
PropertyInfo = property,
Name = property.Name,
};
var actionContext = GetControllerContext();
var modelMetadataProvider = new TestModelMetadataProvider();
var model = new DerivedModel {
DerivedProperty = "some value"
};
var modelBindingResult = ModelBindingResult.Success(model);
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
var modelMetadata = modelMetadataProvider.GetMetadataForProperty(property.DeclaringType, property.Name);
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
CreateMockValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.Same(model, result.Model);
Assert.False(actionContext.ModelState.IsValid);
Assert.Collection(
actionContext.ModelState,
kvp =>
{
Assert.Equal($"{property.Name}", kvp.Key);
var error = Assert.Single(kvp.Value.Errors);
Assert.Equal("Always Invalid", error.ErrorMessage);
});
}
private static DefaultModelBindingContext GetBindingContextForReadOnlyArray(HttpContext httpContext)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty <ModelWithReadOnlyArray>(nameof(ModelWithReadOnlyArray.ArrayProperty))
.BindingDetails(bd => bd.BindingSource = BindingSource.Header);
var modelMetadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithReadOnlyArray),
nameof(ModelWithReadOnlyArray.ArrayProperty));
return(GetBindingContext(metadataProvider, modelMetadata, httpContext));
}
public void AddModelError_ForSingleExpression_AddsExpectedException_WithModelMetadata()
{
// Arrange
var dictionary = new ModelStateDictionary();
var exception = new Exception();
var provider = new TestModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(TestModel), nameof(TestModel.Text));
// Act
dictionary.AddModelError <TestModel>(model => model.Text, exception, metadata);
// Assert
var modelState = Assert.Single(dictionary);
var modelError = Assert.Single(modelState.Value.Errors);
Assert.Equal("Text", modelState.Key);
Assert.Same(exception, modelError.Exception);
}
public void AddModelError_ForImplicitlyCastedToObjectExpression_AddsExpectedException()
{
// Arrange
var dictionary = new ModelStateDictionary();
var exception = new Exception();
var provider = new TestModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(ChildModel), nameof(ChildModel.Value));
// Act
dictionary.AddModelError <TestModel>(model => model.Child.Value, exception, metadata);
// Assert
var modelState = Assert.Single(dictionary);
var modelError = Assert.Single(modelState.Value.Errors);
Assert.Equal("Child.Value", modelState.Key);
Assert.Same(exception, modelError.Exception);
}
public void AddModelError_ForNotModelsExpression_AddsExpectedException()
{
// Arrange
var dictionary = new ModelStateDictionary();
var variable = "Test";
var exception = new Exception();
var provider = new TestModelMetadataProvider();
var metadata = provider.GetMetadataForProperty(typeof(string), nameof(string.Length));
// Act
dictionary.AddModelError <TestModel>(model => variable, exception, metadata);
// Assert
var modelState = Assert.Single(dictionary);
var modelError = Assert.Single(modelState.Value.Errors);
Assert.Equal("variable", modelState.Key);
Assert.Same(exception, modelError.Exception);
}
public void CreateBinder_CreatesNoOpBinder_WhenPropertyBindingIsNotAllowed()
{
// Arrange
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty <Widget>(nameof(Widget.Id))
.BindingDetails(m => m.IsBindingAllowed = false);
var modelBinder = new ByteArrayModelBinder(NullLoggerFactory.Instance);
var options = Options.Create(new MvcOptions());
options.Value.ModelBinderProviders.Add(new TestModelBinderProvider(c =>
{
if (c.Metadata.ModelType == typeof(WidgetId))
{
return(modelBinder);
}
return(null);
}));
var factory = new ModelBinderFactory(
metadataProvider,
options,
GetServices());
var context = new ModelBinderFactoryContext()
{
Metadata = metadataProvider.GetMetadataForProperty(typeof(Widget), nameof(Widget.Id)),
};
// Act
var result = factory.CreateBinder(context);
// Assert
Assert.NotNull(result);
Assert.IsType <NoOpBinder>(result);
}
