huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Support model binding to Razor Pages properties on page and PageModel classes 

Fixes #5952
This commit is contained in:
Pranav K 2017-03-14 17:02:51 -07:00
parent d2430f0f4e
commit e7101f248a
51 changed files with 2411 additions and 1140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
samples/MvcSandbox/Controllers/HomeController.cs
View File

@ -7,6 +7,9 @@ namespace MvcSandbox.Controllers
{
public class HomeController : Controller
{
[ModelBinder]
public string Id { get; set; }
public IActionResult Index()
{
return View();

2
src/Microsoft.AspNetCore.Mvc.Core/DependencyInjection/MvcCoreServiceCollectionExtensions.cs
View File

@ -172,7 +172,6 @@ namespace Microsoft.Extensions.DependencyInjection
ServiceDescriptor.Transient<IActionInvokerProvider, ControllerActionInvokerProvider>());
// These are stateless
services.TryAddSingleton<IControllerArgumentBinder, DefaultControllerArgumentBinder>();
services.TryAddSingleton<ControllerActionInvokerCache>();
services.TryAddEnumerable(
ServiceDescriptor.Singleton<IFilterProvider, DefaultFilterProvider>());
@ -195,6 +194,7 @@ namespace Microsoft.Extensions.DependencyInjection
return new DefaultObjectValidator(metadataProvider, options.ModelValidatorProviders);
});
services.TryAddSingleton<ClientValidatorCache>();
services.TryAddSingleton<ParameterBinder>();
//
// Random Infrastructure

87
src/Microsoft.AspNetCore.Mvc.Core/Internal/ControllerActionInvoker.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Core;
using Microsoft.AspNetCore.Mvc.Core.Internal;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.Logging;
namespace Microsoft.AspNetCore.Mvc.Internal
@ -18,7 +19,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
public class ControllerActionInvoker : ResourceInvoker, IActionInvoker
{
private readonly IControllerFactory _controllerFactory;
private readonly IControllerArgumentBinder _controllerArgumentBinder;
private readonly ParameterBinder _parameterBinder;
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly ControllerContext _controllerContext;
private readonly ObjectMethodExecutor _executor;
@ -36,7 +38,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
public ControllerActionInvoker(
IControllerFactory controllerFactory,
IControllerArgumentBinder controllerArgumentBinder,
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
ILogger logger,
DiagnosticSource diagnosticSource,
ControllerContext controllerContext,
@ -50,9 +53,9 @@ namespace Microsoft.AspNetCore.Mvc.Internal
throw new ArgumentNullException(nameof(controllerFactory));
}
if (controllerArgumentBinder == null)
if (parameterBinder == null)
{
throw new ArgumentNullException(nameof(controllerArgumentBinder));
throw new ArgumentNullException(nameof(parameterBinder));
}
if (objectMethodExecutor == null)
@ -61,7 +64,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
}
_controllerFactory = controllerFactory;
_controllerArgumentBinder = controllerArgumentBinder;
_parameterBinder = parameterBinder;
_modelMetadataProvider = modelMetadataProvider;
_controllerContext = controllerContext;
_executor = objectMethodExecutor;
}
@ -291,7 +295,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
_controller = _controllerFactory.CreateController(controllerContext);
_arguments = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
var task = _controllerArgumentBinder.BindArgumentsAsync(controllerContext, _controller, _arguments);
var task = BindArgumentsAsync();
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.ActionNext;
@ -972,6 +977,76 @@ namespace Microsoft.AspNetCore.Mvc.Internal
}
}
private Task BindArgumentsAsync()
{
// Perf: Avoid allocating async state machines where possible. We only need the state
// machine if you need to bind properties or arguments.
var actionDescriptor = _controllerContext.ActionDescriptor;
if (actionDescriptor.BoundProperties.Count == 0 &&
actionDescriptor.Parameters.Count == 0)
{
return TaskCache.CompletedTask;
}
return BindArgumentsCoreAsync(_parameterBinder, _modelMetadataProvider, _controllerContext, _controller, _arguments);
}
// Intentionally static internal for unit testing
internal static async Task BindArgumentsCoreAsync(
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
ControllerContext controllerContext,
object controller,
Dictionary<string, object> arguments)
{
var valueProvider = await CompositeValueProvider.CreateAsync(controllerContext);
var parameters = controllerContext.ActionDescriptor.Parameters;
for (var i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
var result = await parameterBinder.BindModelAsync(controllerContext, valueProvider, parameter);
if (result.IsModelSet)
{
arguments[parameter.Name] = result.Model;
}
}
var propertyDescriptors = controllerContext.ActionDescriptor.BoundProperties;
if (propertyDescriptors.Count == 0)
{
// Perf: Early exit to avoid PropertyHelper lookup in the (common) case where we have no
// bound properties.
return;
}
var controllerType = controller.GetType();
ModelMetadata controllerMetadata = null;
for (var i = 0; i < propertyDescriptors.Count; i++)
{
var property = propertyDescriptors[i];
var result = await parameterBinder.BindModelAsync(controllerContext, valueProvider, property);
if (result.IsModelSet)
{
if (controllerMetadata == null)
{
controllerMetadata = modelMetadataProvider.GetMetadataForType(controllerType);
}
var propertyMetadata = controllerMetadata.Properties[property.Name] ??
modelMetadataProvider.GetMetadataForProperty(controllerType, property.Name);
if (propertyMetadata != null)
{
PropertyValueSetter.SetValue(
propertyMetadata,
controller,
result.Model);
}
}
}
}
private enum Scope
{
Resource,

12
src/Microsoft.AspNetCore.Mvc.Core/Internal/ControllerActionInvokerProvider.cs
View File

@ -15,9 +15,10 @@ namespace Microsoft.AspNetCore.Mvc.Internal
{
public class ControllerActionInvokerProvider : IActionInvokerProvider
{
private readonly IControllerArgumentBinder _argumentBinder;
private readonly IControllerFactory _controllerFactory;
private readonly ControllerActionInvokerCache _controllerActionInvokerCache;
private readonly ParameterBinder _parameterBinder;
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly IReadOnlyList<IValueProviderFactory> _valueProviderFactories;
private readonly int _maxModelValidationErrors;
private readonly ILogger _logger;
@ -26,14 +27,16 @@ namespace Microsoft.AspNetCore.Mvc.Internal
public ControllerActionInvokerProvider(
IControllerFactory controllerFactory,
ControllerActionInvokerCache controllerActionInvokerCache,
IControllerArgumentBinder argumentBinder,
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
IOptions<MvcOptions> optionsAccessor,
ILoggerFactory loggerFactory,
DiagnosticSource diagnosticSource)
{
_controllerFactory = controllerFactory;
_controllerActionInvokerCache = controllerActionInvokerCache;
_argumentBinder = argumentBinder;
_parameterBinder = parameterBinder;
_modelMetadataProvider = modelMetadataProvider;
_valueProviderFactories = optionsAccessor.Value.ValueProviderFactories.ToArray();
_maxModelValidationErrors = optionsAccessor.Value.MaxModelValidationErrors;
_logger = loggerFactory.CreateLogger<ControllerActionInvoker>();
@ -66,7 +69,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
context.Result = new ControllerActionInvoker(
_controllerFactory,
_argumentBinder,
_parameterBinder,
_modelMetadataProvider,
_logger,
_diagnosticSource,
controllerContext,

279
src/Microsoft.AspNetCore.Mvc.Core/Internal/DefaultControllerArgumentBinder.cs
View File

@ -1,279 +0,0 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Core;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.Extensions.Internal;
namespace Microsoft.AspNetCore.Mvc.Internal
{
/// <summary>
/// Provides a default implementation of <see cref="IControllerArgumentBinder"/>.
/// Uses ModelBinding to populate action parameters.
/// </summary>
public class DefaultControllerArgumentBinder : IControllerArgumentBinder
{
private static readonly MethodInfo CallPropertyAddRangeOpenGenericMethod =
typeof(DefaultControllerArgumentBinder).GetTypeInfo().GetDeclaredMethod(
nameof(CallPropertyAddRange));
private readonly IModelBinderFactory _modelBinderFactory;
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly IObjectModelValidator _validator;
public DefaultControllerArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
{
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_validator = validator;
}
public Task BindArgumentsAsync(
ControllerContext controllerContext,
object controller,
IDictionary<string, object> arguments)
{
if (controllerContext == null)
{
throw new ArgumentNullException(nameof(controllerContext));
}
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
if (controllerContext.ActionDescriptor == null)
{
throw new ArgumentException(Resources.FormatPropertyOfTypeCannotBeNull(
nameof(ControllerContext.ActionDescriptor),
nameof(ControllerContext)));
}
// Perf: Avoid allocating async state machines where possible. We only need the state
// machine if you need to bind properties.
var actionDescriptor = controllerContext.ActionDescriptor;
if (actionDescriptor.BoundProperties.Count == 0 &&
actionDescriptor.Parameters.Count == 0)
{
return TaskCache.CompletedTask;
}
return BindArgumentsCoreAsync(controllerContext, controller, arguments);
}
private async Task BindArgumentsCoreAsync(
ControllerContext controllerContext,
object controller,
IDictionary<string, object> arguments)
{
var valueProvider = await CompositeValueProvider.CreateAsync(controllerContext);
var parameters = controllerContext.ActionDescriptor.Parameters;
for (var i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
var result = await BindModelAsync(parameter, controllerContext, valueProvider);
if (result.IsModelSet)
{
arguments[parameter.Name] = result.Model;
}
}
var properties = controllerContext.ActionDescriptor.BoundProperties;
if (properties.Count == 0)
{
// Perf: Early exit to avoid PropertyHelper lookup in the (common) case where we have no
// bound properties.
return;
}
var propertyHelpers = PropertyHelper.GetProperties(controller);
for (var i = 0; i < properties.Count; i++)
{
var property = properties[i];
var result = await BindModelAsync(property, controllerContext, valueProvider);
if (result.IsModelSet)
{
var propertyHelper = FindPropertyHelper(propertyHelpers, property);
if (propertyHelper != null)
{
ActivateProperty(property, propertyHelper, controller, result.Model);
}
}
}
}
public async Task<ModelBindingResult> BindModelAsync(
ParameterDescriptor parameter,
ControllerContext controllerContext)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (controllerContext == null)
{
throw new ArgumentNullException(nameof(controllerContext));
}
var valueProvider = await CompositeValueProvider.CreateAsync(controllerContext);
return await BindModelAsync(parameter, controllerContext, valueProvider);
}
public async Task<ModelBindingResult> BindModelAsync(
ParameterDescriptor parameter,
ControllerContext controllerContext,
IValueProvider valueProvider)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (controllerContext == null)
{
throw new ArgumentNullException(nameof(controllerContext));
}
if (valueProvider == null)
{
throw new ArgumentNullException(nameof(valueProvider));
}
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var binder = _modelBinderFactory.CreateBinder(new ModelBinderFactoryContext()
{
BindingInfo = parameter.BindingInfo,
Metadata = metadata,
CacheToken = parameter,
});
var modelBindingContext = DefaultModelBindingContext.CreateBindingContext(
controllerContext,
valueProvider,
metadata,
parameter.BindingInfo,
parameter.Name);
var parameterModelName = parameter.BindingInfo?.BinderModelName ?? metadata.BinderModelName;
if (parameterModelName != null)
{
// The name was set explicitly, always use that as the prefix.
modelBindingContext.ModelName = parameterModelName;
}
else if (modelBindingContext.ValueProvider.ContainsPrefix(parameter.Name))
{
// We have a match for the parameter name, use that as that prefix.
modelBindingContext.ModelName = parameter.Name;
}
else
{
// No match, fallback to empty string as the prefix.
modelBindingContext.ModelName = string.Empty;
}
await binder.BindModelAsync(modelBindingContext);
var modelBindingResult = modelBindingContext.Result;
if (modelBindingResult.IsModelSet)
{
_validator.Validate(
controllerContext,
modelBindingContext.ValidationState,
modelBindingContext.ModelName,
modelBindingResult.Model);
}
return modelBindingResult;
}
private void ActivateProperty(
ParameterDescriptor property,
PropertyHelper propertyHelper,
object controller,
object value)
{
var propertyType = propertyHelper.Property.PropertyType;
var metadata = _modelMetadataProvider.GetMetadataForType(propertyType);
if (propertyHelper.Property.CanWrite && propertyHelper.Property.SetMethod?.IsPublic == true)
{
// Handle settable property. Do not set the property to null if the type is a non-nullable type.
if (value != null || metadata.IsReferenceOrNullableType)
{
propertyHelper.SetValue(controller, value);
}
return;
}
if (propertyType.IsArray)
{
// Do not attempt to copy values into an array because an array's length is immutable. This choice
// is also consistent with MutableObjectModelBinder's handling of a read-only array property.
return;
}
var target = propertyHelper.GetValue(controller);
if (value == null || target == null)
{
// Nothing to do when source or target is null.
return;
}
if (!metadata.IsCollectionType)
{
// Not a collection model.
return;
}
// Handle a read-only collection property.
var propertyAddRange = CallPropertyAddRangeOpenGenericMethod.MakeGenericMethod(
metadata.ElementMetadata.ModelType);
propertyAddRange.Invoke(obj: null, parameters: new[] { target, value });
}
// Called via reflection.
private static void CallPropertyAddRange<TElement>(object target, object source)
{
var targetCollection = (ICollection<TElement>)target;
var sourceCollection = source as IEnumerable<TElement>;
if (sourceCollection != null && !targetCollection.IsReadOnly)
{
targetCollection.Clear();
foreach (var item in sourceCollection)
{
targetCollection.Add(item);
}
}
}
private static PropertyHelper FindPropertyHelper(PropertyHelper[] propertyHelpers, ParameterDescriptor property)
{
for (var i = 0; i < propertyHelpers.Length; i++)
{
var propertyHelper = propertyHelpers[i];
if (string.Equals(propertyHelper.Name, property.Name, StringComparison.Ordinal))
{
return propertyHelper;
}
}
return null;
}
}
}

28
src/Microsoft.AspNetCore.Mvc.Core/Internal/IControllerArgumentBinder.cs
View File

@ -1,28 +0,0 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Threading.Tasks;
namespace Microsoft.AspNetCore.Mvc.Internal
{
/// <summary>
/// Provides a dictionary of action arguments.
/// </summary>
public interface IControllerArgumentBinder
{
/// <summary>
/// Asyncronously binds a dictionary of the parameter-argument name-value pairs,
/// which can be used to invoke the action. Also binds properties explicitly marked properties on the
/// <paramref name="controller"/>.
/// </summary>
/// <param name="controllerContext">The <see cref="ControllerContext"/> associated with the current action.</param>
/// <param name="controller">The controller object which contains the action.</param>
/// <param name="arguments">The arguments dictionary.</param>
/// <returns>A <see cref="Task"/> which, when completed signals the completion of argument binding.</returns>
Task BindArgumentsAsync(
ControllerContext controllerContext,
object controller,
IDictionary<string, object> arguments);
}
}

72
src/Microsoft.AspNetCore.Mvc.Core/Internal/PropertyValueSetter.cs Normal file
View File

@ -0,0 +1,72 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Reflection;
using Microsoft.AspNetCore.Mvc.ModelBinding;
namespace Microsoft.AspNetCore.Mvc.Internal
{
public static class PropertyValueSetter
{
private static readonly MethodInfo CallPropertyAddRangeOpenGenericMethod =
typeof(PropertyValueSetter).GetMethod(nameof(CallPropertyAddRange), BindingFlags.NonPublic | BindingFlags.Static);
public static void SetValue(
ModelMetadata metadata,
object instance,
object value)
{
if (!metadata.IsReadOnly)
{
// Handle settable property. Do not set the property to null if the type is a non-nullable type.
if (value != null || metadata.IsReferenceOrNullableType)
{
metadata.PropertySetter(instance, value);
}
return;
}
if (metadata.ModelType.IsArray)
{
// Do not attempt to copy values into an array because an array's length is immutable. This choice
// is also consistent with ComplexTypeModelBinder's handling of a read-only array property.
return;
}
if (!metadata.IsCollectionType)
{
// Not a collection model.
return;
}
var target = metadata.PropertyGetter(instance);
if (value == null || target == null)
{
// Nothing to do when source or target is null.
return;
}
// Handle a read-only collection property.
var propertyAddRange = CallPropertyAddRangeOpenGenericMethod.MakeGenericMethod(
metadata.ElementMetadata.ModelType);
propertyAddRange.Invoke(obj: null, parameters: new[] { target, value });
}
// Called via reflection.
private static void CallPropertyAddRange<TElement>(object target, object source)
{
var targetCollection = (ICollection<TElement>)target;
var sourceCollection = source as IEnumerable<TElement>;
if (sourceCollection != null && !targetCollection.IsReadOnly)
{
targetCollection.Clear();
foreach (var item in sourceCollection)
{
targetCollection.Add(item);
}
}
}
}
}

143
src/Microsoft.AspNetCore.Mvc.Core/ModelBinding/ParameterBinder.cs Normal file
View File

@ -0,0 +1,143 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
namespace Microsoft.AspNetCore.Mvc.ModelBinding
{
/// <summary>
/// Binds and validates models specified by a <see cref="ParameterDescriptor"/>.
/// </summary>
public class ParameterBinder
{
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly IModelBinderFactory _modelBinderFactory;
private readonly IObjectModelValidator _validator;
/// <summary>
/// Initializes a new instance of <see cref="ParameterDescriptor"/>.
/// </summary>
/// <param name="modelMetadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="modelBinderFactory">The <see cref="IModelBinderFactory"/>.</param>
/// <param name="validator">The <see cref="IObjectModelValidator"/>.</param>
public ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
{
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
if (modelBinderFactory == null)
{
throw new ArgumentNullException(nameof(modelBinderFactory));
}
if (validator == null)
{
throw new ArgumentNullException(nameof(validator));
}
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_validator = validator;
}
/// <summary>
/// Initializes and binds a model specified by <paramref name="parameter"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/>.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/>.</param>
/// <param name="parameter">The <see cref="ParameterDescriptor"/></param>
/// <returns>The result of model binding.</returns>
public Task<ModelBindingResult> BindModelAsync(
ActionContext actionContext,
IValueProvider valueProvider,
ParameterDescriptor parameter)
{
return BindModelAsync(actionContext, valueProvider, parameter, value: null);
}
/// <summary>
/// Binds a model specified by <paramref name="parameter"/> using <paramref name="value"/> as the initial value.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/>.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/>.</param>
/// <param name="parameter">The <see cref="ParameterDescriptor"/></param>
/// <param name="value">The initial model value.</param>
/// <returns>The result of model binding.</returns>
public virtual async Task<ModelBindingResult> BindModelAsync(
ActionContext actionContext,
IValueProvider valueProvider,
ParameterDescriptor parameter,
object value)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (valueProvider == null)
{
throw new ArgumentNullException(nameof(valueProvider));
}
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var binder = _modelBinderFactory.CreateBinder(new ModelBinderFactoryContext()
{
BindingInfo = parameter.BindingInfo,
Metadata = metadata,
CacheToken = parameter,
});
var modelBindingContext = DefaultModelBindingContext.CreateBindingContext(
actionContext,
valueProvider,
metadata,
parameter.BindingInfo,
parameter.Name);
modelBindingContext.Model = value;
var parameterModelName = parameter.BindingInfo?.BinderModelName ?? metadata.BinderModelName;
if (parameterModelName != null)
{
// The name was set explicitly, always use that as the prefix.
modelBindingContext.ModelName = parameterModelName;
}
else if (modelBindingContext.ValueProvider.ContainsPrefix(parameter.Name))
{
// We have a match for the parameter name, use that as that prefix.
modelBindingContext.ModelName = parameter.Name;
}
else
{
// No match, fallback to empty string as the prefix.
modelBindingContext.ModelName = string.Empty;
}
await binder.BindModelAsync(modelBindingContext);
var modelBindingResult = modelBindingContext.Result;
if (modelBindingResult.IsModelSet)
{
_validator.Validate(
actionContext,
modelBindingContext.ValidationState,
modelBindingContext.ModelName,
modelBindingResult.Model);
}
return modelBindingResult;
}
}
}

18
src/Microsoft.AspNetCore.Mvc.RazorPages/Infrastructure/PageArgumentBinder.cs
View File

@ -15,26 +15,26 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure
return result.IsModelSet ? result.Model : @default;
}
public Task<T> BindModelAsync<T>(PageContext context, string name)
public Task<TModel> BindModelAsync<TModel>(PageContext context, string name)
{
return BindModelAsync<T>(context, default(T), name);
return BindModelAsync(context, default(TModel), name);
}
public async Task<T> BindModelAsync<T>(PageContext context, T @default, string name)
public async Task<TModel> BindModelAsync<TModel>(PageContext context, TModel @default, string name)
{
var result = await BindAsync(context, null, name, typeof(T));
return result.IsModelSet ? (T)result.Model : @default;
var result = await BindAsync(context, null, name, typeof(TModel));
return result.IsModelSet ? (TModel)result.Model : @default;
}
public async Task<bool> TryUpdateModelAsync<T>(PageContext context, T value)
public async Task<bool> TryUpdateModelAsync<TModel>(PageContext context, TModel value)
{
var result = await BindAsync(context, value, string.Empty, typeof(T));
var result = await BindAsync(context, value, string.Empty, typeof(TModel));
return result.IsModelSet && context.ModelState.IsValid;
}
public async Task<bool> TryUpdateModelAsync<T>(PageContext context, T value, string name)
public async Task<bool> TryUpdateModelAsync<TModel>(PageContext context, TModel value, string name)
{
var result = await BindAsync(context, value, name, typeof(T));
var result = await BindAsync(context, value, name, typeof(TModel));
return result.IsModelSet && context.ModelState.IsValid;
}

71
src/Microsoft.AspNetCore.Mvc.RazorPages/Internal/DefaultPageArgumentBinder.cs
View File

@ -3,29 +3,35 @@
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
{
public class DefaultPageArgumentBinder : PageArgumentBinder
{
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly IModelBinderFactory _modelBinderFactory;
private readonly IObjectModelValidator _validator;
private readonly ParameterBinder _parameterBinder;
public DefaultPageArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
public DefaultPageArgumentBinder(ParameterBinder binder)
{
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_validator = validator;
_parameterBinder = binder;
}
protected override async Task<ModelBindingResult> BindAsync(PageContext pageContext, object value, string name, Type type)
{
var valueProvider = await GetCompositeValueProvider(pageContext);
var parameterDescriptor = new ParameterDescriptor
{
BindingInfo = null,
Name = name,
ParameterType = type,
};
return await _parameterBinder.BindModelAsync(pageContext, valueProvider, parameterDescriptor, value);
}
private static async Task<CompositeValueProvider> GetCompositeValueProvider(PageContext pageContext)
{
var factories = pageContext.ValueProviderFactories;
var valueProviderFactoryContext = new ValueProviderFactoryContext(pageContext);
@ -35,48 +41,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
await factory.CreateValueProviderAsync(valueProviderFactoryContext);
}
var valueProvider = new CompositeValueProvider(valueProviderFactoryContext.ValueProviders);
var metadata = _modelMetadataProvider.GetMetadataForType(type);
var binder = _modelBinderFactory.CreateBinder(new ModelBinderFactoryContext()
{
BindingInfo = null,
Metadata = metadata,
CacheToken = null,
});
var modelBindingContext = DefaultModelBindingContext.CreateBindingContext(
pageContext,
valueProvider,
metadata,
null,
name);
modelBindingContext.Model = value;
if (modelBindingContext.ValueProvider.ContainsPrefix(name))
{
// We have a match for the parameter name, use that as that prefix.
modelBindingContext.ModelName = name;
}
else
{
// No match, fallback to empty string as the prefix.
modelBindingContext.ModelName = string.Empty;
}
await binder.BindModelAsync(modelBindingContext);
var result = modelBindingContext.Result;
if (result.IsModelSet)
{
_validator.Validate(
pageContext,
modelBindingContext.ValidationState,
modelBindingContext.ModelName,
result.Model);
}
return result;
return new CompositeValueProvider(valueProviderFactoryContext.ValueProviders);
}
}
}

7
src/Microsoft.AspNetCore.Mvc.RazorPages/Internal/PageActionInvoker.cs
View File

@ -341,6 +341,13 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
_pageContext.ViewData.Model = _model;
}
if (CacheEntry.PropertyBinder != null &&
!string.Equals(_pageContext.HttpContext.Request.Method, "GET", StringComparison.OrdinalIgnoreCase))
{
// Don't bind properties on GET requests
await CacheEntry.PropertyBinder(_page, _model);
}
// This is a workaround for not yet having proper filter for Pages.
SaveTempDataPropertyFilter propertyFilter = null;
for (var i = 0; i < _filters.Length; i++)

19
src/Microsoft.AspNetCore.Mvc.RazorPages/Internal/PageActionInvokerCacheEntry.cs
View File

@ -3,6 +3,7 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.Razor;
@ -16,6 +17,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
Action<PageContext, object> releasePage,
Func<PageContext, object> modelFactory,
Action<PageContext, object> releaseModel,
Func<Page, object, Task> propertyBinder,
IReadOnlyList<Func<IRazorPage>> pageStartFactories,
FilterItem[] cacheableFilters)
{
@ -24,6 +26,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
ReleasePage = releasePage;
ModelFactory = modelFactory;
ReleaseModel = releaseModel;
PropertyBinder = propertyBinder;
PageStartFactories = pageStartFactories;
CacheableFilters = cacheableFilters;
}
@ -39,16 +42,22 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
public Func<PageContext, object> ModelFactory { get; }
/// <summary>
/// The delegate invoked to release a model. This may be <c>null</c>.
/// </summary>
public Action<PageContext, object> ReleaseModel { get; }
/// <summary>
/// The delegate invoked to bind either the handler type (page or model).
/// This may be <c>null</c>.
/// </summary>
public Func<Page, object, Task> PropertyBinder { get; }
/// <summary>
/// Gets the applicable PageStarts.
/// </summary>
public IReadOnlyList<Func<IRazorPage>> PageStartFactories { get; }
/// <summary>
/// The action invoked to release a model. This may be <c>null</c>.
/// </summary>
public Action<PageContext, object> ReleaseModel { get; }
public FilterItem[] CacheableFilters { get; }
}
}

8
src/Microsoft.AspNetCore.Mvc.RazorPages/Internal/PageActionInvokerProvider.cs
View File

@ -33,6 +33,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
private readonly IActionDescriptorCollectionProvider _collectionProvider;
private readonly IFilterProvider[] _filterProviders;
private readonly IReadOnlyList<IValueProviderFactory> _valueProviderFactories;
private readonly ParameterBinder _parameterBinder;
private readonly IModelMetadataProvider _modelMetadataProvider;
private readonly ITempDataDictionaryFactory _tempDataFactory;
private readonly HtmlHelperOptions _htmlHelperOptions;
@ -51,6 +52,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
IRazorPageFactoryProvider razorPageFactoryProvider,
IActionDescriptorCollectionProvider collectionProvider,
IEnumerable<IFilterProvider> filterProviders,
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
ITempDataDictionaryFactory tempDataFactory,
IOptions<MvcOptions> mvcOptions,
@ -69,6 +71,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
_collectionProvider = collectionProvider;
_filterProviders = filterProviders.ToArray();
_valueProviderFactories = mvcOptions.Value.ValueProviderFactories.ToArray();
_parameterBinder = parameterBinder;
_modelMetadataProvider = modelMetadataProvider;
_tempDataFactory = tempDataFactory;
_htmlHelperOptions = htmlHelperOptions.Value;
@ -174,6 +177,10 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
var pageFactory = _pageFactoryProvider.CreatePageFactory(compiledActionDescriptor);
var pageDisposer = _pageFactoryProvider.CreatePageDisposer(compiledActionDescriptor);
var propertyBinder = PagePropertyBinderFactory.CreateBinder(
_parameterBinder,
_modelMetadataProvider,
compiledActionDescriptor);
Func<PageContext, object> modelFactory = null;
Action<PageContext, object> modelReleaser = null;
@ -197,6 +204,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
pageDisposer,
modelFactory,
modelReleaser,
propertyBinder,
pageStartFactories,
cachedFilters);
}

153
src/Microsoft.AspNetCore.Mvc.RazorPages/Internal/PagePropertyBinderFactory.cs Normal file
View File

@ -0,0 +1,153 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Internal;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.Extensions.Internal;
namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
{
public static class PagePropertyBinderFactory
{
public static Func<Page, object, Task> CreateBinder(
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
CompiledPageActionDescriptor actionDescriptor)
{
if (parameterBinder == null)
{
throw new ArgumentNullException(nameof(parameterBinder));
}
if (actionDescriptor == null)
{
throw new ArgumentNullException(nameof(actionDescriptor));
}
var bindPropertiesOnPage = actionDescriptor.ModelTypeInfo == null;
var target = bindPropertiesOnPage ? actionDescriptor.PageTypeInfo : actionDescriptor.ModelTypeInfo;
var propertiesToBind = GetPropertiesToBind(modelMetadataProvider, target);
if (propertiesToBind.Count == 0)
{
return null;
}
return Bind;
Task Bind(Page page, object model)
{
if (page == null)
{
throw new ArgumentNullException(nameof(page));
}
if (!bindPropertiesOnPage && model == null)
{
throw new ArgumentNullException(nameof(model));
}
var pageContext = page.PageContext;
var instance = bindPropertiesOnPage ? page : model;
return BindPropertiesAsync(parameterBinder, pageContext, instance, propertiesToBind);
}
}
private static async Task BindPropertiesAsync(
ParameterBinder parameterBinder,
PageContext pageContext,
object instance,
IList<PropertyBindingInfo> propertiesToBind)
{
var valueProvider = await GetCompositeValueProvider(pageContext);
for (var i = 0; i < propertiesToBind.Count; i++)
{
var propertyBindingInfo = propertiesToBind[i];
var modelBindingResult = await parameterBinder.BindModelAsync(
pageContext,
valueProvider,
propertyBindingInfo.ParameterDescriptor);
if (modelBindingResult.IsModelSet)
{
var modelMetadata = propertyBindingInfo.ModelMetadata;
PropertyValueSetter.SetValue(
modelMetadata,
instance,
modelBindingResult.Model);
}
}
}
private static IList<PropertyBindingInfo> GetPropertiesToBind(
IModelMetadataProvider modelMetadataProvider,
TypeInfo handlerSourceTypeInfo)
{
var handlerType = handlerSourceTypeInfo.AsType();
var properties = PropertyHelper.GetVisibleProperties(type: handlerType);
var typeMetadata = modelMetadataProvider.GetMetadataForType(handlerType);
var propertyBindingInfo = new List<PropertyBindingInfo>();
for (var i = 0; i < properties.Length; i++)
{
var property = properties[i];
var bindingInfo = BindingInfo.GetBindingInfo(property.Property.GetCustomAttributes());
if (bindingInfo == null)
{
continue;
}
var propertyMetadata = typeMetadata.Properties[property.Name] ??
modelMetadataProvider.GetMetadataForProperty(handlerType, property.Name);
if (propertyMetadata == null)
{
continue;
}
var parameterDescriptor = new ParameterDescriptor
{
BindingInfo = bindingInfo,
Name = property.Name,
ParameterType = property.Property.PropertyType,
};
propertyBindingInfo.Add(new PropertyBindingInfo(parameterDescriptor, propertyMetadata));
}
return propertyBindingInfo;
}
private static async Task<CompositeValueProvider> GetCompositeValueProvider(PageContext pageContext)
{
var factories = pageContext.ValueProviderFactories;
var valueProviderFactoryContext = new ValueProviderFactoryContext(pageContext);
for (var i = 0; i < factories.Count; i++)
{
var factory = factories[i];
await factory.CreateValueProviderAsync(valueProviderFactoryContext);
}
return new CompositeValueProvider(valueProviderFactoryContext.ValueProviders);
}
private struct PropertyBindingInfo
{
public PropertyBindingInfo(
ParameterDescriptor parameterDescriptor,
ModelMetadata modelMetadata)
{
ParameterDescriptor = parameterDescriptor;
ModelMetadata = modelMetadata;
}
public ParameterDescriptor ParameterDescriptor { get; }
public ModelMetadata ModelMetadata { get; }
}
}
}

351
test/Microsoft.AspNetCore.Mvc.Core.Test/Internal/DefaultControllerArgumentBinderTests.cs → test/Microsoft.AspNetCore.Mvc.Core.Test/Internal/ControllerActionInvokerParameterBindingTest.cs
View File

@ -3,13 +3,13 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.AspNetCore.Routing;
using Moq;
@ -17,7 +17,7 @@ using Xunit;
namespace Microsoft.AspNetCore.Mvc.Internal
{
public class DefaultControllerArgumentBinderTests
public class ControllerActionInvokerParameterBindingTest
{
[Fact]
public async Task BindActionArgumentsAsync_DoesNotAddActionArguments_IfBinderReturnsNull()
@ -37,14 +37,19 @@ namespace Microsoft.AspNetCore.Mvc.Internal
.Setup(b => b.BindModelAsync(It.IsAny<DefaultModelBindingContext>()))
.Returns(TaskCache.CompletedTask);
var factory = GetModelBinderFactory(binder.Object);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
var controllerContext = GetControllerContext(actionDescriptor);
var controller = new TestController();
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Empty(arguments);
@ -68,14 +73,19 @@ namespace Microsoft.AspNetCore.Mvc.Internal
.Setup(b => b.BindModelAsync(It.IsAny<DefaultModelBindingContext>()))
.Returns(TaskCache.CompletedTask);
var factory = GetModelBinderFactory(binder.Object);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
var controllerContext = GetControllerContext(actionDescriptor);
var controller = new TestController();
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Empty(arguments);
@ -108,14 +118,19 @@ namespace Microsoft.AspNetCore.Mvc.Internal
})
.Returns(TaskCache.CompletedTask);
var factory = GetModelBinderFactory(binder.Object);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
var controllerContext = GetControllerContext(actionDescriptor);
var controller = new TestController();
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal(1, arguments.Count);
@ -146,12 +161,17 @@ namespace Microsoft.AspNetCore.Mvc.Internal
It.IsAny<string>(),
It.IsAny<object>()));
var argumentBinder = GetArgumentBinder(factory, mockValidator.Object);
var parameterBinder = GetParameterBinder(factory, mockValidator.Object);
var controller = new TestController();
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
mockValidator
@ -195,10 +215,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var factory = GetModelBinderFactory(binder.Object);
var controller = new TestController();
var argumentBinder = GetArgumentBinder(factory, mockValidator.Object);
var parameterBinder = GetParameterBinder(factory, mockValidator.Object);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
mockValidator
@ -235,10 +260,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
It.IsAny<object>()));
var factory = GetModelBinderFactory("Hello");
var argumentBinder = GetArgumentBinder(factory, mockValidator.Object);
var parameterBinder = GetParameterBinder(factory, mockValidator.Object);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
mockValidator
@ -281,10 +311,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
It.IsAny<object>()));
var factory = GetModelBinderFactory(binder.Object);
var argumentBinder = GetArgumentBinder(factory, mockValidator.Object);
var parameterBinder = GetParameterBinder(factory, mockValidator.Object);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
mockValidator
@ -314,11 +349,16 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
var factory = GetModelBinderFactory("Hello");
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal("Hello", controller.StringProperty);
@ -345,10 +385,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var expected = new List<string> { "Hello", "World", "!!" };
var factory = GetModelBinderFactory(expected);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal(expected, controller.CollectionProperty);
@ -377,14 +422,19 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var binder = new StubModelBinder(ModelBindingResult.Success(model: null));
var factory = GetModelBinderFactory(binder);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Some non default value.
controller.NonNullableProperty = -1;
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal(-1, controller.NonNullableProperty);
@ -409,14 +459,19 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var binder = new StubModelBinder(ModelBindingResult.Success(model: null));
var factory = GetModelBinderFactory(binder);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Some non default value.
controller.NullableProperty = -1;
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Null(controller.NullableProperty);
@ -485,11 +540,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
var factory = GetModelBinderFactory(inputValue);
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal(expectedValue, propertyAccessor(controller));
@ -549,7 +608,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
object model;
if (inputPropertyValues.TryGetValue(bindingContext.FieldName, out model))
{
bindingContext.Result = ModelBindingResult.Success( model);
bindingContext.Result = ModelBindingResult.Success(model);
}
else
{
@ -560,10 +619,15 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var factory = GetModelBinderFactory(binder);
controllerContext.ValueProviderFactories.Add(new SimpleValueProviderFactory());
var argumentBinder = GetArgumentBinder(factory);
var parameterBinder = GetParameterBinder(factory);
// Act
await argumentBinder.BindArgumentsAsync(controllerContext, controller, arguments);
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
controllerContext,
controller,
arguments);
// Assert
Assert.Equal(new string[] { "goodbye" }, controller.ArrayProperty); // Skipped
@ -574,141 +638,136 @@ namespace Microsoft.AspNetCore.Mvc.Internal
Assert.Equal("Hello", controller.StringProperty);
}
public static TheoryData BindModelAsyncData
private class TransferInfo
{
[Range(25, 50)]
public int AccountId { get; set; }
public double Amount { get; set; }
}
public static TheoryData<List<ParameterDescriptor>> MultipleActionParametersAndValidationData
{
get
{
var emptyBindingInfo = new BindingInfo();
var bindingInfoWithName = new BindingInfo
return new TheoryData<List<ParameterDescriptor>>
{
BinderModelName = "bindingInfoName",
BinderType = typeof(Person),
};
// parameterBindingInfo, metadataBinderModelName, parameterName, expectedBinderModelName
return new TheoryData<BindingInfo, string, string, string>
{
// If the parameter name is not a prefix match, it is ignored. But name is required to create a
// ModelBindingContext.
{ null, null, "parameterName", string.Empty },
{ emptyBindingInfo, null, "parameterName", string.Empty },
{ bindingInfoWithName, null, "parameterName", "bindingInfoName" },
{ null, "modelBinderName", "parameterName", "modelBinderName" },
{ null, null, "parameterName", string.Empty },
// Parameter's BindingInfo has highest precedence
{ bindingInfoWithName, "modelBinderName", "parameterName", "bindingInfoName" },
// Irrespective of the order in which the parameters are defined on the action,
// the validation on the TransferInfo's AccountId should occur.
// Here 'accountId' parameter is bound by the prefix 'accountId' while the 'transferInfo'
// property is bound using the empty prefix and the 'TransferInfo' property names.
new List<ParameterDescriptor>()
{
new ParameterDescriptor()
{
Name = "accountId",
ParameterType = typeof(int)
},
new ParameterDescriptor()
{
Name = "transferInfo",
ParameterType = typeof(TransferInfo),
BindingInfo = new BindingInfo()
{
BindingSource = BindingSource.Body
}
}
},
new List<ParameterDescriptor>()
{
new ParameterDescriptor()
{
Name = "transferInfo",
ParameterType = typeof(TransferInfo),
BindingInfo = new BindingInfo()
{
BindingSource = BindingSource.Body
}
},
new ParameterDescriptor()
{
Name = "accountId",
ParameterType = typeof(int)
}
}
};
}
}
[Theory]
[MemberData(nameof(BindModelAsyncData))]
public async Task BindModelAsync_PassesExpectedBindingInfoAndMetadata_IfPrefixDoesNotMatch(
BindingInfo parameterBindingInfo,
string metadataBinderModelName,
string parameterName,
string expectedModelName)
[MemberData(nameof(MultipleActionParametersAndValidationData))]
public async Task MultipleActionParameter_ValidModelState(List<ParameterDescriptor> parameters)
{
// Since validation attribute is only present on the FromBody model's property(TransferInfo's AccountId),
// validation should not trigger for the parameter which is bound from Uri.
// Arrange
var metadataProvider = new TestModelMetadataProvider();
metadataProvider.ForType<Person>().BindingDetails(binding =>
var actionDescriptor = new ControllerActionDescriptor()
{
binding.BinderModelName = metadataBinderModelName;
});
var metadata = metadataProvider.GetMetadataForType(typeof(Person));
var modelBinder = new Mock<IModelBinder>();
modelBinder
.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Callback((ModelBindingContext context) =>
{
Assert.Equal(expectedModelName, context.ModelName, StringComparer.Ordinal);
})
.Returns(TaskCache.CompletedTask);
var parameterDescriptor = new ParameterDescriptor
{
BindingInfo = parameterBindingInfo,
Name = parameterName,
ParameterType = typeof(Person),
BoundProperties = new List<ParameterDescriptor>(),
Parameters = parameters
};
var factory = new Mock<IModelBinderFactory>(MockBehavior.Strict);
factory
.Setup(f => f.CreateBinder(It.IsAny<ModelBinderFactoryContext>()))
.Callback((ModelBinderFactoryContext context) =>
{
// Confirm expected data is passed through to ModelBindingFactory.
Assert.Same(parameterDescriptor.BindingInfo, context.BindingInfo);
Assert.Same(parameterDescriptor, context.CacheToken);
Assert.Equal(metadata, context.Metadata);
})
.Returns(modelBinder.Object);
var argumentBinder = new DefaultControllerArgumentBinder(
metadataProvider,
factory.Object,
var modelMetadataProvider = new EmptyModelMetadataProvider();
var parameterBinder = new Mock<ParameterBinder>(
new EmptyModelMetadataProvider(),
TestModelBinderFactory.CreateDefault(),
CreateMockValidator());
var controllerContext = GetControllerContext();
controllerContext.ActionDescriptor.Parameters.Add(parameterDescriptor);
// Act & Assert
await argumentBinder.BindModelAsync(parameterDescriptor, controllerContext);
}
[Fact]
public async Task BindModelAsync_PassesExpectedBindingInfoAndMetadata_IfPrefixMatches()
{
// Arrange
var expectedModelName = "expectedName";
var metadataProvider = new TestModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(Person));
var modelBinder = new Mock<IModelBinder>();
modelBinder
.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Callback((ModelBindingContext context) =>
parameterBinder.Setup(p => p.BindModelAsync(
It.IsAny<ActionContext>(),
It.IsAny<IValueProvider>(),
It.IsAny<ParameterDescriptor>(),
null))
.Returns((ActionContext context, IValueProvider valueProvider, ParameterDescriptor descriptor, object v) =>
{
Assert.Equal(expectedModelName, context.ModelName, StringComparer.Ordinal);
})
.Returns(TaskCache.CompletedTask);
ModelBindingResult result;
if (descriptor.Name == "accountId")
{
result = ModelBindingResult.Success(10);
}
else if (descriptor.Name == "transferInfo")
{
result = ModelBindingResult.Success(new TransferInfo
{
AccountId = 40,
Amount = 250.0
});
}
else
{
result = ModelBindingResult.Failed();
}
var parameterDescriptor = new ParameterDescriptor
return Task.FromResult(result);
});
var testContext = new ControllerContext
{
Name = expectedModelName,
ParameterType = typeof(Person),
ActionDescriptor = actionDescriptor,
};
var factory = new Mock<IModelBinderFactory>(MockBehavior.Strict);
factory
.Setup(f => f.CreateBinder(It.IsAny<ModelBinderFactoryContext>()))
.Callback((ModelBinderFactoryContext context) =>
{
// Confirm expected data is passed through to ModelBindingFactory.
Assert.Null(context.BindingInfo);
Assert.Same(parameterDescriptor, context.CacheToken);
Assert.Equal(metadata, context.Metadata);
})
.Returns(modelBinder.Object);
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
var modelState = testContext.ModelState;
var argumentBinder = new DefaultControllerArgumentBinder(
metadataProvider,
factory.Object,
CreateMockValidator());
// Act
await ControllerActionInvoker.BindArgumentsCoreAsync(
parameterBinder.Object,
TestModelMetadataProvider.CreateDefaultProvider(),
testContext,
new TestController(),
arguments);
var valueProvider = new SimpleValueProvider
{
{ expectedModelName, new object() },
};
var valueProviderFactory = new SimpleValueProviderFactory(valueProvider);
var controllerContext = GetControllerContext();
controllerContext.ActionDescriptor.Parameters.Add(parameterDescriptor);
controllerContext.ValueProviderFactories.Insert(0, valueProviderFactory);
// Act & Assert
await argumentBinder.BindModelAsync(parameterDescriptor, controllerContext);
// Assert
Assert.True(modelState.IsValid);
object value;
Assert.True(arguments.TryGetValue("accountId", out value));
var accountId = Assert.IsType<int>(value);
Assert.Equal(10, accountId);
Assert.True(arguments.TryGetValue("transferInfo", out value));
var transferInfo = Assert.IsType<TransferInfo>(value);
Assert.NotNull(transferInfo);
Assert.Equal(40, transferInfo.AccountId);
Assert.Equal(250.0, transferInfo.Amount);
}
private static ControllerContext GetControllerContext(ControllerActionDescriptor descriptor = null)
@ -760,7 +819,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
return TestModelBinderFactory.Create(provider.Object);
}
private static DefaultControllerArgumentBinder GetArgumentBinder(
private static ParameterBinder GetParameterBinder(
IModelBinderFactory factory = null,
IObjectModelValidator validator = null)
{
@ -774,7 +833,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
factory = TestModelBinderFactory.CreateDefault();
}
return new DefaultControllerArgumentBinder(
return new ParameterBinder(
TestModelMetadataProvider.CreateDefaultProvider(),
factory,
validator);

175
test/Microsoft.AspNetCore.Mvc.Core.Test/Internal/ControllerActionInvokerTest.cs
View File

@ -16,7 +16,6 @@ using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.AspNetCore.Routing;
@ -2909,22 +2908,22 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var context = new Mock<HttpContext>();
context.SetupGet(c => c.Items)
.Returns(new Dictionary<object, object>());
.Returns(new Dictionary<object, object>());
context.Setup(c => c.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(new NullLoggerFactory());
.Returns(new NullLoggerFactory());
var actionContext = new ActionContext(context.Object, new RouteData(), actionDescriptor);
var controllerFactory = new Mock<IControllerFactory>();
controllerFactory.Setup(c => c.CreateController(It.IsAny<ControllerContext>()))
.Returns(new TestController());
.Returns(new TestController());
var metadataProvider = new EmptyModelMetadataProvider();
var argumentBinder = new DefaultControllerArgumentBinder(
metadataProvider,
TestModelBinderFactory.CreateDefault(metadataProvider),
new DefaultObjectValidator(metadataProvider, new IModelValidatorProvider[0]));
var parameterBinder = new ParameterBinder(
metadataProvider,
TestModelBinderFactory.CreateDefault(metadataProvider),
new DefaultObjectValidator(metadataProvider, new IModelValidatorProvider[0]));
var controllerContext = new ControllerContext(actionContext)
{
@ -2934,7 +2933,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var invoker = new ControllerActionInvoker(
controllerFactory.Object,
argumentBinder,
parameterBinder,
metadataProvider,
new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(),
new DiagnosticListener("Microsoft.AspNetCore"),
controllerContext,
@ -2969,12 +2969,13 @@ namespace Microsoft.AspNetCore.Mvc.Internal
actionDescriptor.ControllerTypeInfo = typeof(ControllerActionInvokerTest).GetTypeInfo();
actionDescriptor.FilterDescriptors = new List<FilterDescriptor>();
actionDescriptor.Parameters = new List<ParameterDescriptor>();
actionDescriptor.BoundProperties = new List<ParameterDescriptor>();
var filter = Mock.Of<IFilterMetadata>();
var invoker = CreateInvoker(
new[] { filter },
actionDescriptor,
controllerArgumentBinder: null,
parameterBinder: null,
controller: null,
logger: logger);
@ -3001,6 +3002,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
BoundProperties = new List<ParameterDescriptor>(),
};
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod(
@ -3016,7 +3018,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var invoker = CreateInvoker(
new[] { filter },
actionDescriptor,
controllerArgumentBinder: null,
parameterBinder: null,
controller: null,
diagnosticListener: listener,
routeData: routeData);
@ -3043,6 +3045,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
BoundProperties = new List<ParameterDescriptor>(),
};
actionDescriptor.MethodInfo = typeof(ControllerActionInvokerTest).GetMethod(
@ -3055,7 +3058,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var invoker = CreateInvoker(
new[] { filter },
actionDescriptor,
controllerArgumentBinder: null,
parameterBinder: null,
controller: null,
diagnosticListener: listener);
@ -3067,6 +3070,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
Assert.NotNull(listener.AfterAction?.HttpContext);
}
[Fact]
public async Task InvokeAction_ExceptionBubbling_AsyncActionFilter_To_ResourceFilter()
{
// Arrange
@ -3129,6 +3133,7 @@ namespace Microsoft.AspNetCore.Mvc.Internal
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
BoundProperties = new List<ParameterDescriptor>(),
};
if (actionThrows)
@ -3157,38 +3162,54 @@ namespace Microsoft.AspNetCore.Mvc.Internal
{
FilterDescriptors = new List<FilterDescriptor>(),
Parameters = new List<ParameterDescriptor>(),
BoundProperties = new List<ParameterDescriptor>(),
MethodInfo = typeof(TestController).GetMethod(methodName),
ControllerTypeInfo = typeof(TestController).GetTypeInfo(),
};
actionDescriptor.MethodInfo = typeof(TestController).GetMethod(methodName);
actionDescriptor.ControllerTypeInfo = typeof(TestController).GetTypeInfo();
foreach (var argument in arguments)
{
actionDescriptor.Parameters.Add(new ParameterDescriptor
{
Name = argument.Key,
ParameterType = argument.Value.GetType(),
});
}
var argumentBinder = new TestControllerArgumentBinder(arguments);
var parameterBinder = new TestParameterBinder(arguments);
return CreateInvoker(filters, actionDescriptor, argumentBinder, _controller, maxAllowedErrorsInModelState);
return CreateInvoker(filters, actionDescriptor, _controller, parameterBinder, maxAllowedErrorsInModelState);
}
private TestControllerActionInvoker CreateInvoker(
IFilterMetadata[] filters,
ControllerActionDescriptor actionDescriptor,
IControllerArgumentBinder controllerArgumentBinder,
object controller,
ParameterBinder parameterBinder = null,
int maxAllowedErrorsInModelState = 200,
List<IValueProviderFactory> valueProviderFactories = null,
RouteData routeData = null,
ILogger logger = null,
object diagnosticListener = null)
{
var httpContext = new Mock<HttpContext>(MockBehavior.Loose);
var httpContext = new DefaultHttpContext();
var options = new MvcOptions();
var mvcOptionsAccessor = new TestOptionsManager<MvcOptions>(options);
var http = GetHttpContext();
var services = new ServiceCollection();
services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);
services.AddSingleton<IOptions<MvcOptions>>(mvcOptionsAccessor);
services.AddSingleton(new ObjectResultExecutor(
mvcOptionsAccessor,
new TestHttpResponseStreamWriterFactory(),
NullLoggerFactory.Instance));
var httpRequest = http.Request;
var httpResponse = http.Response;
services.AddSingleton(new ContentResultExecutor(
NullLogger<ContentResultExecutor>.Instance,
new MemoryPoolHttpResponseStreamWriterFactory(ArrayPool<byte>.Shared, ArrayPool<char>.Shared)));
httpContext.SetupGet(c => c.Request).Returns(httpRequest);
httpContext.SetupGet(c => c.Response).Returns(httpResponse);
httpResponse.Body = new MemoryStream();
httpContext.Response.Body = new MemoryStream();
httpContext.RequestServices = services.BuildServiceProvider();
var formatter = new Mock<IOutputFormatter>();
formatter
@ -3202,63 +3223,21 @@ namespace Microsoft.AspNetCore.Mvc.Internal
await c.HttpContext.Response.WriteAsync(c.Object.ToString());
});
var options = new MvcOptions();
options.OutputFormatters.Add(formatter.Object);
var optionsAccessor = new Mock<IOptions<MvcOptions>>();
optionsAccessor
.SetupGet(o => o.Value)
.Returns(options);
httpContext
.Setup(o => o.RequestServices.GetService(typeof(ILoggerFactory)))
.Returns(NullLoggerFactory.Instance);
httpContext
.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor.Object);
httpContext.SetupGet(c => c.Items)
.Returns(new Dictionary<object, object>());
httpContext
.Setup(o => o.RequestServices.GetService(typeof(ObjectResultExecutor)))
.Returns(new ObjectResultExecutor(
optionsAccessor.Object,
new TestHttpResponseStreamWriterFactory(),
NullLoggerFactory.Instance));
httpContext
.Setup(o => o.RequestServices.GetService(typeof(ContentResultExecutor)))
.Returns(new ContentResultExecutor(
new Logger<ContentResultExecutor>(NullLoggerFactory.Instance),
new MemoryPoolHttpResponseStreamWriterFactory(ArrayPool<byte>.Shared, ArrayPool<char>.Shared)));
if (routeData == null)
{
routeData = new RouteData();
}
var actionContext = new ActionContext(
httpContext: httpContext.Object,
httpContext: httpContext,
routeData: routeData,
actionDescriptor: actionDescriptor);
IControllerArgumentBinder argumentBinder = null;
if (controllerArgumentBinder == null)
if (parameterBinder == null)
{
var mockBinder = new Mock<IControllerArgumentBinder>();
mockBinder
.Setup(b => b.BindArgumentsAsync(
It.IsAny<ControllerContext>(),
It.IsAny<object>(),
It.IsAny<IDictionary<string, object>>()))
.Returns(TaskCache.CompletedTask);
argumentBinder = mockBinder.Object;
}
else
{
argumentBinder = controllerArgumentBinder;
parameterBinder = new TestParameterBinder(new Dictionary<string, object>());
}
if (valueProviderFactories == null)
@ -3280,7 +3259,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var invoker = new TestControllerActionInvoker(
filters,
new MockControllerFactory(controller ?? this),
argumentBinder,
parameterBinder,
TestModelMetadataProvider.CreateDefaultProvider(),
logger,
diagnosticSource,
actionContext,
@ -3299,30 +3279,6 @@ namespace Microsoft.AspNetCore.Mvc.Internal
throw _actionException;
}
private static IServiceCollection CreateServices()
{
var services = new ServiceCollection();
services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);
return services;
}
private static HttpContext GetHttpContext()
{
var services = CreateServices();
var httpContext = new DefaultHttpContext();
httpContext.RequestServices = services.BuildServiceProvider();
return httpContext;
}
public IActionResult ActionMethodWithBodyParameter([FromBody] Person bodyParam)
{
return new ObjectResult(bodyParam);
}
public class Person
{
public string Name { get; set; }
@ -3529,7 +3485,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
public TestControllerActionInvoker(
IFilterMetadata[] filters,
MockControllerFactory controllerFactory,
IControllerArgumentBinder argumentBinder,
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
ILogger logger,
DiagnosticSource diagnosticSource,
ActionContext actionContext,
@ -3537,7 +3494,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
int maxAllowedErrorsInModelState)
: base(
controllerFactory,
argumentBinder,
parameterBinder,
modelMetadataProvider,
logger,
diagnosticSource,
CreatControllerContext(actionContext, valueProviderFactories, maxAllowedErrorsInModelState),
@ -3593,25 +3551,30 @@ namespace Microsoft.AspNetCore.Mvc.Internal
}
}
private class TestControllerArgumentBinder : IControllerArgumentBinder
private class TestParameterBinder : ParameterBinder
{
private readonly IDictionary<string, object> _actionParameters;
public TestControllerArgumentBinder(IDictionary<string, object> actionParameters)
public TestParameterBinder(IDictionary<string, object> actionParameters)
: base(
new EmptyModelMetadataProvider(),
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>())
{
_actionParameters = actionParameters;
}
public Task BindArgumentsAsync(
ControllerContext controllerContext,
object controller,
IDictionary<string, object> arguments)
public override Task<ModelBindingResult> BindModelAsync(
ActionContext actionContext,
IValueProvider valueProvider,
ParameterDescriptor parameter,
object value)
{
foreach (var entry in _actionParameters)
if (_actionParameters.TryGetValue(parameter.Name, out var result))
{
arguments.Add(entry.Key, entry.Value);
return Task.FromResult(ModelBindingResult.Success(result));
}
return TaskCache.CompletedTask;
return Task.FromResult(ModelBindingResult.Failed());
}
}
}

32
test/Microsoft.AspNetCore.Mvc.Core.Test/Internal/MiddlewareFilterTest.cs
View File

@ -16,6 +16,7 @@ using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
@ -282,7 +283,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
var invoker = new TestControllerActionInvoker(
filters,
new MockControllerFactory(controller ?? this),
new TestControllerArgumentBinder(actionParameters: null),
new TestParameterBinder(actionParameters: null),
TestModelMetadataProvider.CreateDefaultProvider(),
new NullLoggerFactory().CreateLogger<ControllerActionInvoker>(),
diagnosticSource,
actionContext,
@ -392,7 +394,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
public TestControllerActionInvoker(
IFilterMetadata[] filters,
MockControllerFactory controllerFactory,
IControllerArgumentBinder argumentBinder,
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
ILogger logger,
DiagnosticSource diagnosticSource,
ActionContext actionContext,
@ -400,7 +403,8 @@ namespace Microsoft.AspNetCore.Mvc.Internal
int maxAllowedErrorsInModelState)
: base(
controllerFactory,
argumentBinder,
parameterBinder,
modelMetadataProvider,
logger,
diagnosticSource,
CreatControllerContext(actionContext, valueProviderFactories, maxAllowedErrorsInModelState),
@ -440,14 +444,32 @@ namespace Microsoft.AspNetCore.Mvc.Internal
}
}
private class TestControllerArgumentBinder : IControllerArgumentBinder
private class TestParameterBinder : ParameterBinder
{
private readonly IDictionary<string, object> _actionParameters;
public TestControllerArgumentBinder(IDictionary<string, object> actionParameters)
public TestParameterBinder(IDictionary<string, object> actionParameters)
: base(
new EmptyModelMetadataProvider(),
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>())
{
_actionParameters = actionParameters;
}
public override Task<ModelBindingResult> BindModelAsync(
ActionContext actionContext,
IValueProvider valueProvider,
ParameterDescriptor parameter,
object value)
{
if (_actionParameters.TryGetValue(parameter.Name, out var result))
{
return Task.FromResult(ModelBindingResult.Success(result));
}
return Task.FromResult(ModelBindingResult.Failed());
}
public Task BindArgumentsAsync(
ControllerContext controllerContext,
object controller,

184
test/Microsoft.AspNetCore.Mvc.Core.Test/ModelBinding/ParameterBinderTest.cs Normal file
View File

@ -0,0 +1,184 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Internal;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Moq;
using Xunit;
namespace Microsoft.AspNetCore.Mvc.ModelBinding
{
public class ParameterBinderTest
{
public static TheoryData BindModelAsyncData
{
get
{
var emptyBindingInfo = new BindingInfo();
var bindingInfoWithName = new BindingInfo
{
BinderModelName = "bindingInfoName",
BinderType = typeof(Person),
};
// parameterBindingInfo, metadataBinderModelName, parameterName, expectedBinderModelName
return new TheoryData<BindingInfo, string, string, string>
{
// If the parameter name is not a prefix match, it is ignored. But name is required to create a
// ModelBindingContext.
{ null, null, "parameterName", string.Empty },
{ emptyBindingInfo, null, "parameterName", string.Empty },
{ bindingInfoWithName, null, "parameterName", "bindingInfoName" },
{ null, "modelBinderName", "parameterName", "modelBinderName" },
{ null, null, "parameterName", string.Empty },
// Parameter's BindingInfo has highest precedence
{ bindingInfoWithName, "modelBinderName", "parameterName", "bindingInfoName" },
};
}
}
[Theory]
[MemberData(nameof(BindModelAsyncData))]
public async Task BindModelAsync_PassesExpectedBindingInfoAndMetadata_IfPrefixDoesNotMatch(
BindingInfo parameterBindingInfo,
string metadataBinderModelName,
string parameterName,
string expectedModelName)
{
// Arrange
var binderExecuted = false;
var metadataProvider = new TestModelMetadataProvider();
metadataProvider.ForType<Person>().BindingDetails(binding =>
{
binding.BinderModelName = metadataBinderModelName;
});
var metadata = metadataProvider.GetMetadataForType(typeof(Person));
var modelBinder = new Mock<IModelBinder>();
modelBinder
.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Callback((ModelBindingContext context) =>
{
Assert.Equal(expectedModelName, context.ModelName, StringComparer.Ordinal);
})
.Returns(TaskCache.CompletedTask);
var parameterDescriptor = new ParameterDescriptor
{
BindingInfo = parameterBindingInfo,
Name = parameterName,
ParameterType = typeof(Person),
};
var factory = new Mock<IModelBinderFactory>(MockBehavior.Strict);
factory
.Setup(f => f.CreateBinder(It.IsAny<ModelBinderFactoryContext>()))
.Callback((ModelBinderFactoryContext context) =>
{
binderExecuted = true;
// Confirm expected data is passed through to ModelBindingFactory.
Assert.Same(parameterDescriptor.BindingInfo, context.BindingInfo);
Assert.Same(parameterDescriptor, context.CacheToken);
Assert.Equal(metadata, context.Metadata);
})
.Returns(modelBinder.Object);
var parameterBinder = new ParameterBinder(
metadataProvider,
factory.Object,
CreateMockValidator());
var controllerContext = new ControllerContext();
// Act & Assert
await parameterBinder.BindModelAsync(controllerContext, new SimpleValueProvider(), parameterDescriptor);
Assert.True(binderExecuted);
}
[Fact]
public async Task BindModelAsync_PassesExpectedBindingInfoAndMetadata_IfPrefixMatches()
{
// Arrange
var expectedModelName = "expectedName";
var binderExecuted = false;
var metadataProvider = new TestModelMetadataProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(Person));
var modelBinder = new Mock<IModelBinder>();
modelBinder
.Setup(b => b.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Callback((ModelBindingContext context) =>
{
Assert.Equal(expectedModelName, context.ModelName, StringComparer.Ordinal);
})
.Returns(TaskCache.CompletedTask);
var parameterDescriptor = new ParameterDescriptor
{
Name = expectedModelName,
ParameterType = typeof(Person),
};
var factory = new Mock<IModelBinderFactory>(MockBehavior.Strict);
factory
.Setup(f => f.CreateBinder(It.IsAny<ModelBinderFactoryContext>()))
.Callback((ModelBinderFactoryContext context) =>
{
binderExecuted = true;
// Confirm expected data is passed through to ModelBindingFactory.
Assert.Null(context.BindingInfo);
Assert.Same(parameterDescriptor, context.CacheToken);
Assert.Equal(metadata, context.Metadata);
})
.Returns(modelBinder.Object);
var argumentBinder = new ParameterBinder(
metadataProvider,
factory.Object,
CreateMockValidator());
var valueProvider = new SimpleValueProvider
{
{ expectedModelName, new object() },
};
var valueProviderFactory = new SimpleValueProviderFactory(valueProvider);
var controllerContext = new ControllerContext();
// Act & Assert
await argumentBinder.BindModelAsync(controllerContext, valueProvider, parameterDescriptor);
Assert.True(binderExecuted);
}
private static IObjectModelValidator CreateMockValidator()
{
var mockValidator = new Mock<IObjectModelValidator>();
mockValidator
.Setup(o => o.Validate(
It.IsAny<ActionContext>(),
It.IsAny<ValidationStateDictionary>(),
It.IsAny<string>(),
It.IsAny<object>()));
return mockValidator.Object;
}
private class Person : IEquatable<Person>, IEquatable<object>
{
public string Name { get; set; }
public bool Equals(Person other)
{
return other != null && string.Equals(Name, other.Name, StringComparison.Ordinal);
}
bool IEquatable<object>.Equals(object obj)
{
return Equals(obj as Person);
}
}
}
}

181
test/Microsoft.AspNetCore.Mvc.FunctionalTests/RazorPagesTest.cs
View File

@ -2,6 +2,7 @@
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
@ -191,7 +192,7 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
// Act
var response = await Client.SendAsync(request);
// Assert
// Assert
var content = await response.Content.ReadAsStringAsync();
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -389,7 +390,7 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
{
// Arrange
var url = "/HelloWorldWithAuth";
// Act
var response = await Client.GetAsync(url);
@ -417,7 +418,7 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
public async Task PageImport_IsDiscoveredWhenRootDirectoryIsNotSpecified()
{
// Test for https://github.com/aspnet/Mvc/issues/5915
//Arrange
// Arrange
var expected = "Hello from CustomService!";
// Act
@ -427,6 +428,180 @@ namespace Microsoft.AspNetCore.Mvc.FunctionalTests
Assert.Equal(expected, response.Trim());
}
[Fact]
public async Task PropertiesOnPageAreBound()
{
// Arrange
var expected = "Id = 10, Name = Foo, Age = 25";
var request = new HttpRequestMessage(HttpMethod.Post, "Pages/PropertyBinding/PagePropertyBinding/10")
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Name", "Foo"),
new KeyValuePair<string, string>("Age", "25"),
}),
};
await AddAntiforgeryHeaders(request);
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
Assert.StartsWith(expected, content.Trim());
}
[Fact]
public async Task PropertiesOnPageAreValidated()
{
// Arrange
var expected = new[]
{
"Id = 27, Name = , Age = 325",
"The Name field is required.",
"The field Age must be between 0 and 99.",
};
var request = new HttpRequestMessage(HttpMethod.Post, "Pages/PropertyBinding/PagePropertyBinding/27")
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Age", "325"),
}),
};
await AddAntiforgeryHeaders(request);
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
foreach (var item in expected)
{
Assert.Contains(item, content);
}
}
[Fact]
public async Task PropertiesOnPageModelAreBound()
{
// Arrange
var expected = "Id = 10, Name = Foo, Age = 25";
var request = new HttpRequestMessage(HttpMethod.Post, "Pages/PropertyBinding/PageModelWithPropertyBinding/10")
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Name", "Foo"),
new KeyValuePair<string, string>("Age", "25"),
}),
};
await AddAntiforgeryHeaders(request);
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
Assert.StartsWith(expected, content.Trim());
}
[Fact]
public async Task PropertiesOnPageModelAreValidated()
{
// Arrange
var url = "Pages/PropertyBinding/PageModelWithPropertyBinding/27";
var expected = new[]
{
"Id = 27, Name = , Age = 325",
"The Name field is required.",
"The field Age must be between 0 and 99.",
};
var request = new HttpRequestMessage(HttpMethod.Post, url)
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Age", "325"),
}),
};
await AddAntiforgeryHeaders(request);
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
foreach (var item in expected)
{
Assert.Contains(item, content);
}
}
[Fact]
public async Task HandlerMethodArgumentsAndPropertiesAreModelBound()
{
// Arrange
var expected = "Id = 11, Name = Test-Name, Age = 32";
var request = new HttpRequestMessage(HttpMethod.Post, "Pages/PropertyBinding/PageWithPropertyAndArgumentBinding?id=11")
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Name", "Test-Name"),
new KeyValuePair<string, string>("Age", "32"),
}),
};
await AddAntiforgeryHeaders(request);
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
Assert.StartsWith(expected, content.Trim());
}
[Fact]
public async Task PagePropertiesAreNotBoundInGetRequests()
{
// Arrange
var expected = "Id = 11, Name = , Age =";
var validationError = "The Name field is required.";
var request = new HttpRequestMessage(HttpMethod.Get, "Pages/PropertyBinding/PageWithPropertyAndArgumentBinding?id=11")
{
Content = new FormUrlEncodedContent(new KeyValuePair<string, string>[]
{
new KeyValuePair<string, string>("Name", "Test-Name"),
new KeyValuePair<string, string>("Age", "32"),
}),
};
// Act
var response = await Client.SendAsync(request);
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
Assert.StartsWith(expected, content.Trim());
Assert.DoesNotContain(validationError, content);
}
private async Task AddAntiforgeryHeaders(HttpRequestMessage request)
{
var getResponse = await Client.GetAsync(request.RequestUri);
Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
var getResponseBody = await getResponse.Content.ReadAsStringAsync();
var formToken = AntiforgeryTestHelper.RetrieveAntiforgeryToken(getResponseBody, "");
var cookie = AntiforgeryTestHelper.RetrieveAntiforgeryCookie(getResponse);
request.Headers.Add("Cookie", cookie.Key + "=" + cookie.Value);
request.Headers.Add("RequestVerificationToken", formToken);
}
private static string GetCookie(HttpResponseMessage response)
{
var setCookie = response.Headers.GetValues("Set-Cookie").ToArray();

48
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ActionParametersIntegrationTest.cs
View File

@ -34,7 +34,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_NonSettableCollectionModel_EmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "prefix",
@ -50,7 +50,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var model = new Person3();
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -81,7 +81,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_ReadOnlyCollectionModel_EmptyPrefix_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "prefix",
@ -95,7 +95,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -128,7 +128,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_SettableArrayModel_EmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "prefix",
@ -144,7 +144,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var model = new Person4();
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -176,7 +176,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_NonSettableArrayModel_EmptyPrefix_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "prefix",
@ -190,7 +190,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -212,7 +212,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_NonSettableCollectionModel_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Address",
@ -231,7 +231,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -257,7 +257,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_ReadOnlyCollectionModel_WithPrefix_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Address",
@ -275,7 +275,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -303,7 +303,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_SettableArrayModel_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Address",
@ -322,7 +322,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -348,7 +348,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_NonSettableArrayModel_WithPrefix_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Address",
@ -367,7 +367,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -389,7 +389,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
{
// Arrange
var parameterType = typeof(Class1);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "p",
@ -402,7 +402,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act & Assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => argumentBinder.BindModelAsync(parameter, testContext));
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext));
Assert.Equal(
string.Format(
"Could not create an instance of type '{0}'. Model bound complex types must not be abstract or " +
@ -419,7 +419,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
{
// Arrange
var parameterType = typeof(PointStruct);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
ParameterType = parameterType,
@ -428,7 +428,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var testContext = ModelBindingTestHelper.GetTestContext();
// Act & Assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => argumentBinder.BindModelAsync(parameter, testContext));
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext));
Assert.Equal(
string.Format(
"Could not create an instance of type '{0}'. Model bound complex types must not be abstract or " +
@ -443,7 +443,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_BindingToTypeWithNoParameterlessConstructor_ThrowsException(Type parameterType)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
ParameterType = parameterType,
@ -452,7 +452,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var testContext = ModelBindingTestHelper.GetTestContext();
// Act & Assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => argumentBinder.BindModelAsync(parameter, testContext));
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => parameterBinder.BindModelAsync(parameter, testContext));
Assert.Equal(
string.Format(
"Could not create an instance of type '{0}'. Model bound complex types must not be abstract or " +
@ -465,7 +465,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ActionParameter_CustomModelBinder_CanCreateModels_ForParameterlessConstructorTypes()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(binderProvider: new CustomComplexTypeModelBinderProvider());
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(binderProvider: new CustomComplexTypeModelBinderProvider());
var parameter = new ParameterDescriptor()
{
Name = "prefix",
@ -475,7 +475,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

36
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ArrayModelBinderIntegrationTest.cs
View File

@ -16,7 +16,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfSimpleType_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -31,7 +31,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -56,7 +56,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfSimpleType_WithExplicitPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -75,7 +75,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -100,7 +100,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfSimpleType_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -115,7 +115,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -140,7 +140,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfSimpleType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -155,7 +155,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -175,7 +175,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfComplexType_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -190,7 +190,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -216,7 +216,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfComplexType_WithExplicitPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -235,7 +235,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -261,7 +261,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfComplexType_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -276,7 +276,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -302,7 +302,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfComplexType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -317,7 +317,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -339,7 +339,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ArrayModelBinder_BindsArrayOfComplexTypeHavingInitializedData_WithPrefix_Success_ReadOnly()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -354,7 +354,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

28
test/Microsoft.AspNetCore.Mvc.IntegrationTests/BinderTypeBasedModelBinderIntegrationTest.cs
View File

@ -18,7 +18,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithModelBinderType_NullData_ReturnsNull()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -35,7 +35,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -52,7 +52,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithModelBinderType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -69,7 +69,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -89,7 +89,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -106,7 +106,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -155,7 +155,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BinderTypeOnParameterType_WithData_EmptyPrefix_GetsBound(BindingInfo bindingInfo)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -167,7 +167,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -206,7 +206,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BinderTypeOnProperty_WithData_EmptyPrefix_GetsBound(BindingInfo bindingInfo)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -218,7 +218,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -243,7 +243,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_EmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -255,7 +255,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -279,7 +279,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -294,7 +294,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

8
test/Microsoft.AspNetCore.Mvc.IntegrationTests/BindingSourceMetadataProviderIntegrationTest.cs
View File

@ -30,7 +30,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
setup.Configure(options);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(options);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(options);
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -50,7 +50,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var token = testContext.HttpContext.RequestAborted;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -84,7 +84,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
setup.Configure(options);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(options);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(options);
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -103,7 +103,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult

66
test/Microsoft.AspNetCore.Mvc.IntegrationTests/BodyValidationIntegrationTests.cs
View File

@ -23,7 +23,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var input = "{ \"Name\": \"MVC\", \"Contact\":\"4258959019\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"USA\",\"Price\": 21, " +
"\"ProductDetails\": {\"Detail1\": \"d1\", \"Detail2\": \"d2\", \"Detail3\": \"d3\"}}";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -44,7 +44,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -65,7 +65,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
"\"CompanyName\":\"Microsoft\", \"Country\":\"USA\",\"Price\": 22, " +
"\"ProductDetails\": {\"Detail1\": \"d2\", \"Detail2\": \"d3\", \"Detail3\": \"d4\"}}" +
"]";
var argumentBinding = ModelBindingTestHelper.GetArgumentBinder();
var argumentBinding = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -98,7 +98,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
{
// Arrange
var input = "{ \"Price\": 2, \"ProductDetails\": {\"Detail1\": \"d1\"}}";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -125,7 +125,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var detail3Required = ValidationAttributeUtil.GetRequiredErrorMessage("Detail3");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -148,7 +148,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
// Arrange
var input = "{ \"Contact\":\"4255678765\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"USA\",\"Price\": 21 }";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -171,7 +171,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var productDetailsRequired = ValidationAttributeUtil.GetRequiredErrorMessage("ProductDetails");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -189,7 +189,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var input = "{ \"Contact\":\"4258959019\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"UK\",\"Price\": 21, \"ProductDetails\": {\"Detail1\": \"d1\"," +
" \"Detail2\": \"d2\", \"Detail3\": \"d3\"}}";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -210,7 +210,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -229,7 +229,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var input = "{ \"Name\": \"MVC\", \"Contact\":\"4258959019\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"USA\", \"Version\":\"2\"," +
"\"DatePurchased\": \"/Date(1297246301973)/\", \"Price\" : \"110\" }";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -250,7 +250,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -265,7 +265,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
// Arrange
var input = "{ \"Name\": \"MVC\", \"Contact\":\"425-895-9019\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"USA\",\"Price\": 2}";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -289,7 +289,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var contactLength = ValidationAttributeUtil.GetStringLengthErrorMessage(null, 10, "Contact");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -310,7 +310,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var input = "{ \"Contact\":\"4258959019\", \"Category\":\"Technology\"," +
"\"CompanyName\":\"Microsoft\", \"Country\":\"UK\",\"Version\":\"2\"," +
"\"DatePurchased\": \"/Date(1297246301973)/\", \"Price\" : \"110\" }";
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -331,7 +331,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -359,7 +359,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyAndRequiredOnProperty_EmptyBody_AddsModelStateError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -382,7 +382,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var addressRequired = ValidationAttributeUtil.GetRequiredErrorMessage("Address");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -399,7 +399,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyOnActionParameter_EmptyBody_BindsToNullValue()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -422,7 +422,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -443,7 +443,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyAndRequiredOnValueTypeProperty_EmptyBody_JsonFormatterAddsModelStateError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -464,7 +464,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -502,7 +502,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyAndRequiredOnInnerValueTypeProperty_NotBound_JsonFormatterSuccessful()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -523,7 +523,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -540,7 +540,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyWithInvalidPropertyData_JsonFormatterAddsModelError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -561,7 +561,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -604,7 +604,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyOnTopLevelProperty_RequiredOnSubProperty_AddsModelStateError(string inputText)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
BindingInfo = new BindingInfo
@ -627,7 +627,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var streetRequired = ValidationAttributeUtil.GetRequiredErrorMessage("Street");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -663,7 +663,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBodyOnProperty_Succeeds_IgnoresRequiredOnValueTypeSubProperty(string inputText)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
BindingInfo = new BindingInfo
@ -683,7 +683,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -719,7 +719,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
.ForProperty<Person6>(nameof(Person6.Address))
.BindingDetails(binding => binding.BindingSource = BindingSource.Body);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
Name = "parameter-name",
@ -737,7 +737,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -765,7 +765,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
.ForType<Address6>()
.BindingDetails(binding => binding.BindingSource = BindingSource.Body);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
Name = "parameter-name",
@ -783,7 +783,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

12
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ByteArrayModelBinderIntegrationTest.cs
View File

@ -23,7 +23,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_GetsBound(bool fallBackScenario)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -45,7 +45,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -73,7 +73,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_NoData_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -90,7 +90,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -106,7 +106,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -129,7 +129,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

12
test/Microsoft.AspNetCore.Mvc.IntegrationTests/CancellationTokenModelBinderIntegrationTest.cs
View File

@ -24,7 +24,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -40,7 +40,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -62,7 +62,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithEmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -74,7 +74,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -95,7 +95,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -111,7 +111,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

68
test/Microsoft.AspNetCore.Mvc.IntegrationTests/CollectionModelBinderIntegrationTest.cs
View File

@ -24,7 +24,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfSimpleType_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -39,7 +39,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -66,7 +66,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfSimpleType_WithExplicitPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -85,7 +85,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -104,7 +104,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsCollectionOfSimpleType_EmptyPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -119,7 +119,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -136,7 +136,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfSimpleType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -151,7 +151,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -175,7 +175,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_ImpliedPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -190,7 +190,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -210,7 +210,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_ExplicitPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -229,7 +229,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -247,7 +247,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -262,7 +262,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -285,7 +285,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_WithRequiredProperty_WithPrefix_PartialData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -300,7 +300,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -340,7 +340,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_WithRequiredProperty_WithExplicitPrefix_PartialData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -359,7 +359,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -395,7 +395,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsCollectionOfComplexType_WithRequiredProperty_EmptyPrefix_PartialData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -410,7 +410,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -446,7 +446,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfSimpleType_WithIndex_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -462,7 +462,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -490,7 +490,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsCollectionOfComplexType_WithRequiredProperty_WithIndex_PartialData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -505,7 +505,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -541,7 +541,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_BindsListOfComplexType_WithRequiredProperty_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -556,7 +556,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -583,7 +583,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_UsesCustomIndexes()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -606,7 +606,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -641,7 +641,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CollectionModelBinder_UsesCustomIndexes_AddsErrorsWithCorrectKeys()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -663,7 +663,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -687,7 +687,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -702,7 +702,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -937,7 +937,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
ParameterType = parameterType,
};
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var testContext = ModelBindingTestHelper.GetTestContext(request =>
{
request.Form = new FormCollection(formContent);
@ -945,7 +945,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

267
test/Microsoft.AspNetCore.Mvc.IntegrationTests/MutableObjectModelBinderIntegrationTest.cs → test/Microsoft.AspNetCore.Mvc.IntegrationTests/ComplexTypeModelBinderIntegrationTest.cs
View File

File diff suppressed because it is too large Load Diff

44
test/Microsoft.AspNetCore.Mvc.IntegrationTests/DictionaryModelBinderIntegrationTest.cs
View File

@ -20,7 +20,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfSimpleType_WithPrefixAndKVP_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -35,7 +35,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -60,7 +60,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfSimpleType_WithPrefixAndItem_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -75,7 +75,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -97,7 +97,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfSimpleType_WithIndex_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -113,7 +113,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -145,7 +145,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -164,7 +164,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -184,7 +184,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfSimpleType_EmptyPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -199,7 +199,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -216,7 +216,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfSimpleType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -231,7 +231,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -277,7 +277,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfComplexType_ImpliedPrefix_Success(string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -292,7 +292,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -313,7 +313,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -332,7 +332,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -356,7 +356,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
string queryString)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -371,7 +371,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -396,7 +396,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task DictionaryModelBinder_BindsDictionaryOfComplexType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -411,7 +411,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -514,7 +514,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
ParameterType = parameterType,
};
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var testContext = ModelBindingTestHelper.GetTestContext(request =>
{
request.QueryString = new QueryString(queryString);
@ -522,7 +522,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

4
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ExcludeBindingMetadataProviderIntegrationTest.cs
View File

@ -28,7 +28,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
setup.Configure(options);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(options);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(options);
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -53,7 +53,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult

12
test/Microsoft.AspNetCore.Mvc.IntegrationTests/FormCollectionModelBindingIntegrationTest.cs
View File

@ -32,7 +32,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithEmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -51,7 +51,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -79,7 +79,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -101,7 +101,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -124,7 +124,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_NoData_BindsWithEmptyCollection()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -141,7 +141,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

28
test/Microsoft.AspNetCore.Mvc.IntegrationTests/FormFileModelBindingIntegrationTest.cs
View File

@ -32,7 +32,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithEmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -51,7 +51,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -86,7 +86,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindCollectionProperty_WithData_IsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -100,7 +100,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -132,7 +132,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindCollectionProperty_NoData_IsNotBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -145,7 +145,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -175,7 +175,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindReadOnlyCollectionProperty_WithData_IsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -189,7 +189,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -221,7 +221,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -243,7 +243,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -270,7 +270,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_NoData_DoesNotGetBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -289,7 +289,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -310,7 +310,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "p",
@ -329,7 +329,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

56
test/Microsoft.AspNetCore.Mvc.IntegrationTests/GenericModelBinderIntegrationTest.cs
View File

@ -26,7 +26,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollection_ElementTypeFromGreedyModelBinder_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -42,7 +42,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -65,7 +65,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollection_ElementTypeFromGreedyModelBinder_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -80,7 +80,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -103,7 +103,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollection_ElementTypeFromGreedyModelBinder_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -119,7 +119,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -197,7 +197,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollection_ElementTypeUsesGreedyModelBinder_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(binderProvider: new AddressBinderProvider());
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(binderProvider: new AddressBinderProvider());
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -211,7 +211,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -231,7 +231,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollection_ElementTypeUsesGreedyBindingSource_WithPrefix_NullElement()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -245,7 +245,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -265,7 +265,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsArrayOfDictionary_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -280,7 +280,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -310,7 +310,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsArrayOfDictionary_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -325,7 +325,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -355,7 +355,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsArrayOfDictionary_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -370,7 +370,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -390,7 +390,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollectionOfKeyValuePair_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -405,7 +405,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -434,7 +434,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollectionOfKeyValuePair_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -449,7 +449,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -478,7 +478,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsCollectionOfKeyValuePair_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -493,7 +493,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -513,7 +513,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsDictionaryOfList_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -529,7 +529,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -562,7 +562,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsDictionaryOfList_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -577,7 +577,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -610,7 +610,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task GenericModelBinder_BindsDictionaryOfList_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -625,7 +625,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

24
test/Microsoft.AspNetCore.Mvc.IntegrationTests/HeaderModelBinderIntegrationTest.cs
View File

@ -31,7 +31,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindPropertyFromHeader_NoData_UsesFullPathAsKeyForModelStateErrors()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -47,7 +47,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -70,7 +70,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindPropertyFromHeader_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -86,7 +86,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -115,7 +115,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindPropertyFromHeader_WithData_WithEmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -128,7 +128,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -161,7 +161,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindCollectionPropertyFromHeader_WithData_IsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -174,7 +174,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -208,7 +208,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindReadOnlyCollectionPropertyFromHeader_WithData_IsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -221,7 +221,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -264,7 +264,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
expectedRawValue = expectedValue;
}
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -284,7 +284,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert

52
test/Microsoft.AspNetCore.Mvc.IntegrationTests/KeyValuePairModelBinderIntegrationTest.cs
View File

@ -17,7 +17,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfSimpleType_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -32,7 +32,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -57,7 +57,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_SimpleTypes_WithNoKey_AddsError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "parameter",
@ -70,7 +70,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -103,7 +103,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
binding.ModelBindingMessageProvider.MissingKeyOrValueAccessor = () => $"Hurts when nothing is provided.";
}));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
Name = "parameter",
@ -116,7 +116,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -140,7 +140,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_SimpleTypes_WithNoValue_AddsError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "parameter",
@ -153,7 +153,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -186,7 +186,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
binding.ModelBindingMessageProvider.MissingKeyOrValueAccessor = () => $"Hurts when nothing is provided.";
}));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
@ -200,7 +200,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.False(modelBindingResult.IsModelSet);
@ -224,7 +224,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfSimpleType_WithExplicitPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -243,7 +243,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -268,7 +268,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfSimpleType_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -283,7 +283,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -308,7 +308,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfSimpleType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -323,7 +323,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -344,7 +344,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfComplexType_WithPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -359,7 +359,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -385,7 +385,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfComplexType_WithExplicitPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -404,7 +404,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -430,7 +430,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfComplexType_EmptyPrefix_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -445,7 +445,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -471,7 +471,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfComplexType_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -486,7 +486,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -502,7 +502,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task KeyValuePairModelBinder_BindsKeyValuePairOfArray_Success()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "p",
@ -517,7 +517,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

10
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ModelBindingTestHelper.cs
View File

@ -41,23 +41,23 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
return context;
}
public static DefaultControllerArgumentBinder GetArgumentBinder(
public static ParameterBinder GetParameterBinder(
MvcOptions options = null,
IModelBinderProvider binderProvider = null)
{
if (options == null)
{
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
return GetArgumentBinder(metadataProvider, binderProvider);
return GetParameterBinder(metadataProvider, binderProvider);
}
else
{
var metadataProvider = TestModelMetadataProvider.CreateProvider(options.ModelMetadataDetailsProviders);
return GetArgumentBinder(metadataProvider, binderProvider);
return GetParameterBinder(metadataProvider, binderProvider);
}
}
public static DefaultControllerArgumentBinder GetArgumentBinder(
public static ParameterBinder GetParameterBinder(
IModelMetadataProvider metadataProvider,
IModelBinderProvider binderProvider = null)
{
@ -69,7 +69,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
options.Value.ModelBinderProviders.Insert(0, binderProvider);
}
return new DefaultControllerArgumentBinder(
return new ParameterBinder(
metadataProvider,
new ModelBinderFactory(metadataProvider, options),
GetObjectValidator(metadataProvider, options));

20
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ModelPrefixSelectionIntegrationTest.cs
View File

@ -25,7 +25,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ComplexModel_PrefixSelected_ByValueProvider()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -47,7 +47,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -70,7 +70,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ComplexModel_PrefixSelected_ByValueProviderValue_WithFilteredValueProviders()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -96,7 +96,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -119,7 +119,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ComplexModel_EmptyPrefixSelected_NoMatchingValueProviderValue()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -135,7 +135,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -158,7 +158,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ComplexModel_EmptyPrefixSelected_NoMatchingValueProviderValue_WithFilteredValueProviders()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -184,7 +184,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -207,7 +207,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task ComplexModel_EmptyPrefixSelected_NoMatchingValueProviderValue_WithFilteredValueProviders_NoValues()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -230,7 +230,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

22
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ParameterBinderExtensions.cs Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.ModelBinding;
namespace Microsoft.AspNetCore.Mvc.IntegrationTests
{
public static class ParameterBinderExtensions
{
public static async Task<ModelBindingResult> BindModelAsync(
this ParameterBinder parameterBinder,
ParameterDescriptor parameter,
ControllerContext context)
{
var valueProvider = await CompositeValueProvider.CreateAsync(context);
return await parameterBinder.BindModelAsync(context, valueProvider, parameter);
}
}
}

28
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ServicesModelBinderIntegrationTest.cs
View File

@ -17,7 +17,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameterFromService_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -35,7 +35,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -55,7 +55,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameterFromService_NoPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "ControllerProperty",
@ -72,7 +72,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -91,7 +91,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindEnumerableParameterFromService_NoPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "ControllerProperty",
@ -108,7 +108,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -127,7 +127,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindEnumerableParameterFromService_NoService_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "ControllerProperty",
@ -144,7 +144,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -163,7 +163,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameterFromService_NoService_Throws()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "ControllerProperty",
@ -180,7 +180,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
// Act & Assert
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
() => argumentBinder.BindModelAsync(parameter, testContext));
() => parameterBinder.BindModelAsync(parameter, testContext));
Assert.Contains(typeof(IActionResult).FullName, exception.Message);
}
@ -205,7 +205,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
.ForProperty<Person>(nameof(Person.Service))
.BindingDetails(binding => binding.BindingSource = BindingSource.Services);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
Name = "parameter-name",
@ -218,7 +218,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -245,7 +245,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
.ForType<JsonOutputFormatter>()
.BindingDetails(binding => binding.BindingSource = BindingSource.Services);
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
Name = "parameter-name",
@ -258,7 +258,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

44
test/Microsoft.AspNetCore.Mvc.IntegrationTests/SimpleTypeModelBinderIntegrationTest.cs
View File

@ -20,7 +20,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -40,7 +40,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -68,7 +68,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindProperty_WithData_WithEmptyPrefix_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -84,7 +84,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -112,7 +112,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithData_GetsBound()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -129,7 +129,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -156,7 +156,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithMultipleValues_GetsBoundToFirstValue()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -173,7 +173,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -200,7 +200,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_NonConvertableValue_GetsError()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -217,7 +217,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -259,7 +259,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
binding.ModelBindingMessageProvider.AttemptedValueIsInvalidAccessor =
(value, name) => $"Hmm, '{ value }' is not a valid value for '{ name }'.";
});
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -275,7 +275,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -309,7 +309,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithEmptyData_DoesNotBind(Type parameterType)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -324,7 +324,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -360,7 +360,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
binding.ModelBindingMessageProvider.ValueMustNotBeNullAccessor =
value => $"Hurts when '{ value }' is provided.";
});
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(metadataProvider);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(metadataProvider);
var parameter = new ParameterDescriptor
{
@ -376,7 +376,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult
@ -404,7 +404,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_WithEmptyData_BindsMutableAndNullableObjects(Type parameterType)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -419,7 +419,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -442,7 +442,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_NoData_Fails()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -457,7 +457,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
@ -496,7 +496,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task BindParameter_FromFormData_BindsCorrectly(Dictionary<string, StringValues> personStore)
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "Parameter1",
@ -511,7 +511,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
// ModelBindingResult

169
test/Microsoft.AspNetCore.Mvc.IntegrationTests/ValidationIntegrationTests.cs
View File

@ -89,7 +89,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
BoundProperties = new List<ParameterDescriptor>(),
Parameters = parameters
};
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var testContext = ModelBindingTestHelper.GetTestContext(
request =>
@ -100,11 +100,13 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
},
actionDescriptor: actionDescriptor);
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
var modelState = testContext.ModelState;
// Act
await argumentBinder.BindArgumentsAsync(testContext, new TestController(), arguments);
foreach (var parameter in parameters)
{
await parameterBinder.BindModelAsync(parameter, testContext);
}
// Assert
Assert.False(modelState.IsValid);
@ -129,7 +131,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
BoundProperties = new List<ParameterDescriptor>(),
Parameters = parameters
};
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var testContext = ModelBindingTestHelper.GetTestContext(
request =>
@ -140,23 +142,16 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
},
actionDescriptor: actionDescriptor);
var arguments = new Dictionary<string, object>(StringComparer.Ordinal);
var modelState = testContext.ModelState;
// Act
await argumentBinder.BindArgumentsAsync(testContext, new TestController(), arguments);
foreach (var parameter in parameters)
{
await parameterBinder.BindModelAsync(parameter, testContext);
}
// Assert
Assert.True(modelState.IsValid);
object value;
Assert.True(arguments.TryGetValue("accountId", out value));
var accountId = Assert.IsType<int>(value);
Assert.Equal(10, accountId);
Assert.True(arguments.TryGetValue("transferInfo", out value));
var transferInfo = Assert.IsType<TransferInfo>(value);
Assert.NotNull(transferInfo);
Assert.Equal(40, transferInfo.AccountId);
Assert.Equal(250.0, transferInfo.Amount);
}
private class Order1
@ -169,7 +164,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnSimpleTypeProperty_WithData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -184,7 +179,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -206,7 +201,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnSimpleTypeProperty_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -221,7 +216,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -257,7 +252,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnPOCOProperty_WithData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -272,7 +267,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -295,7 +290,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnPOCOProperty_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -310,7 +305,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -348,7 +343,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnNestedSimpleTypeProperty_WithData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -363,7 +358,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -386,7 +381,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnNestedSimpleTypeProperty_NoDataForRequiredProperty()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -402,7 +397,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -440,7 +435,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnCollectionProperty_WithData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -455,7 +450,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -478,7 +473,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnCollectionProperty_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -494,7 +489,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -527,7 +522,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnPOCOPropertyOfBoundElement_WithData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -542,7 +537,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -564,7 +559,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_RequiredAttribute_OnPOCOPropertyOfBoundElement_NoDataForRequiredProperty()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -580,7 +575,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -613,7 +608,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnPropertyOfPOCO_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -628,7 +623,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -650,7 +645,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnPropertyOfPOCO_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -665,7 +660,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -701,7 +696,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnPropertyOfNestedPOCO_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -716,7 +711,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -738,7 +733,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnPropertyOfNestedPOCO_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -753,7 +748,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -778,7 +773,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnPropertyOfNestedPOCO_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -793,7 +788,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -836,7 +831,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_CustomAttribute_OnPOCOProperty_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -851,7 +846,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -873,7 +868,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_CustomAttribute_OnPOCOProperty_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -888,7 +883,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -943,7 +938,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_CustomAttribute_OnCollectionElement_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -958,7 +953,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -980,7 +975,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_CustomAttribute_OnCollectionElement_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -995,7 +990,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1031,7 +1026,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnProperyOfCollectionElement_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -1046,7 +1041,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1068,7 +1063,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnProperyOfCollectionElement_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -1083,7 +1078,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1108,7 +1103,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_StringLengthAttribute_OnProperyOfCollectionElement_NoData()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -1123,7 +1118,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1148,7 +1143,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_FormatException_ShowsInvalidValueMessage_OnSimpleTypeProperty()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -1163,7 +1158,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1188,7 +1183,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task Validation_OverflowException_ShowsInvalidValueMessage_OnSimpleTypeProperty()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var parameter = new ParameterDescriptor()
{
Name = "parameter",
@ -1203,7 +1198,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1283,11 +1278,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
request => request.QueryString
= new QueryString($"?{nameof(ValidateSomeProperties.NeverValid)}.{nameof(NeverValid.NeverValidProperty)}=1"));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1330,11 +1325,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
request => request.QueryString
= new QueryString($"?{nameof(ValidateSomeProperties.NeverValidBecauseAttribute)}=1"));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1367,11 +1362,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
request => request.QueryString
= new QueryString($"?{nameof(ValidateSomeProperties.ValidateNever)}=1"));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1397,11 +1392,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
};
var testContext = ModelBindingTestHelper.GetTestContext();
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1430,11 +1425,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
var testContext = ModelBindingTestHelper.GetTestContext(
request => request.QueryString = new QueryString($"?{propertyName}=1"));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1496,7 +1491,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
};
var testContext = ModelBindingTestHelper.GetTestContext();
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Add an entry for the ControlLength property so that we can observe Skipped versus Valid states.
@ -1506,7 +1501,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
attemptedValue: null);
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1536,7 +1531,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
request => request.QueryString = new QueryString(
$"?{nameof(ValidateSomePropertiesSometimes.Control)}=1"));
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder();
var parameterBinder = ModelBindingTestHelper.GetParameterBinder();
var modelState = testContext.ModelState;
// Add an entry for the ControlLength property so that we can observe Skipped versus Valid states.
@ -1546,7 +1541,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
attemptedValue: null);
// Act
var result = await argumentBinder.BindModelAsync(parameter, testContext);
var result = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(result.IsModelSet);
@ -1618,11 +1613,11 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
testOptions = options;
});
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(testOptions);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(testOptions);
var modelState = testContext.ModelState;
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
Assert.Equal(3, modelState.Count);
Assert.Equal(0, modelState.ErrorCount);
@ -1648,7 +1643,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBody_JToken_ExcludedFromValidation()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(new TestMvcOptions().Value);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(new TestMvcOptions().Value);
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -1675,7 +1670,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
modelState.SetModelValue("CustomParameter.message", "Hello", "Hello");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1702,7 +1697,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task CancellationToken_WithEmptyPrefix_DoesNotSuppressUnrelatedErrors()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(new TestMvcOptions().Value);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(new TestMvcOptions().Value);
var parameter = new ParameterDescriptor
{
Name = "cancellationToken",
@ -1718,7 +1713,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
modelState.SetModelValue("message", "Hello", "Hello");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1738,7 +1733,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBody_WithEmptyPrefix_DoesNotSuppressUnrelatedErrors_Valid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(new TestMvcOptions().Value);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(new TestMvcOptions().Value);
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -1763,7 +1758,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
modelState.SetModelValue("other.key", "1", "1");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);
@ -1784,7 +1779,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
public async Task FromBody_WithEmptyPrefix_DoesNotSuppressUnrelatedErrors_Invalid()
{
// Arrange
var argumentBinder = ModelBindingTestHelper.GetArgumentBinder(new TestMvcOptions().Value);
var parameterBinder = ModelBindingTestHelper.GetParameterBinder(new TestMvcOptions().Value);
var parameter = new ParameterDescriptor
{
Name = "Parameter1",
@ -1810,7 +1805,7 @@ namespace Microsoft.AspNetCore.Mvc.IntegrationTests
modelState.SetModelValue("other.key", "1", "1");
// Act
var modelBindingResult = await argumentBinder.BindModelAsync(parameter, testContext);
var modelBindingResult = await parameterBinder.BindModelAsync(parameter, testContext);
// Assert
Assert.True(modelBindingResult.IsModelSet);

53
test/Microsoft.AspNetCore.Mvc.RazorPages.Test/Internal/PageActionInvokerProviderTest.cs
View File

@ -11,6 +11,7 @@ using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Microsoft.AspNetCore.Mvc.Razor;
using Microsoft.AspNetCore.Mvc.RazorPages.Infrastructure;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
@ -72,6 +73,43 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
Assert.Null(entry.ReleaseModel);
}
[Fact]
public void OnProvidersExecuting_CachesModelBinderFactory()
{
// Arrange
var descriptor = new PageActionDescriptor()
{
FilterDescriptors = new FilterDescriptor[0],
};
var loader = new Mock<IPageLoader>();
loader.Setup(l => l.Load(It.IsAny<PageActionDescriptor>()))
.Returns(new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithBoundProperties).GetTypeInfo(),
});
var descriptorCollection = new ActionDescriptorCollection(new[] { descriptor }, version: 1);
var actionDescriptorProvider = new Mock<IActionDescriptorCollectionProvider>();
actionDescriptorProvider.Setup(p => p.ActionDescriptors).Returns(descriptorCollection);
var pageFactoryProvider = Mock.Of<IPageFactoryProvider>();
var invokerProvider = CreateInvokerProvider(
loader.Object,
actionDescriptorProvider.Object,
pageFactoryProvider);
var context = new ActionInvokerProviderContext(
new ActionContext(new DefaultHttpContext(), new RouteData(), descriptor));
// Act
invokerProvider.OnProvidersExecuting(context);
// Assert
Assert.NotNull(context.Result);
var actionInvoker = Assert.IsType<PageActionInvoker>(context.Result);
var entry = actionInvoker.CacheEntry;
Assert.NotNull(entry.PropertyBinder);
}
[Fact]
public void OnProvidersExecuting_SetsHandlers()
{
@ -762,6 +800,12 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
razorProject = Mock.Of<RazorProject>();
}
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
return new PageActionInvokerProvider(
loader,
pageProvider ?? Mock.Of<IPageFactoryProvider>(),
@ -769,7 +813,8 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
razorPageFactoryProvider ?? Mock.Of<IRazorPageFactoryProvider>(),
actionDescriptorProvider,
new IFilterProvider[0],
new EmptyModelMetadataProvider(),
parameterBinder,
modelMetadataProvider,
tempDataFactory.Object,
new TestOptionsManager<MvcOptions>(),
new TestOptionsManager<HtmlHelperOptions>(),
@ -890,5 +935,11 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
{
}
}
private class PageWithBoundProperties
{
[ModelBinder]
public string Id { get; set; }
}
}
}

3
test/Microsoft.AspNetCore.Mvc.RazorPages.Test/Internal/PageActionInvokerTest.cs
View File

@ -352,6 +352,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
(context) => null,
null,
null,
null,
new FilterItem[0]);
var invoker = CreateInvoker(
new[] { filter1.Object, filter2.Object, filter3.Object },
@ -406,6 +407,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
(context) => null,
null,
null,
null,
new FilterItem[0]);
var invoker = CreateInvoker(
new IFilterMetadata[] { filter1.Object, filter2.Object, filter3.Object },
@ -604,6 +606,7 @@ namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
_ => Activator.CreateInstance(actionDescriptor.ModelTypeInfo.AsType()),
(c, model) => { (model as IDisposable)?.Dispose(); },
null,
null,
new FilterItem[0]);
var invoker = new PageActionInvoker(

522
test/Microsoft.AspNetCore.Mvc.RazorPages.Test/Internal/PagePropertyBinderFactoryTest.cs Normal file
View File

@ -0,0 +1,522 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.Abstractions;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Validation;
using Moq;
using Xunit;
namespace Microsoft.AspNetCore.Mvc.RazorPages.Internal
{
public class PagePropertyBinderFactoryTest
{
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageHasNoBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithNoBoundProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageModelHasNoBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithNoBoundProperties).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithNoBoundProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
TestModelMetadataProvider.CreateDefaultProvider(),
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageHasNoVisibleBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithNoVisibleBoundProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageModelHasNoVisibleBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(object).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithNoVisibleBoundProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageHasNoSettableBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithReadOnlyProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public void GetModelBinderFactory_ReturnsNullIfPageModelHasNoSettableBoundProperties()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithReadOnlyProperties).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithReadOnlyProperties).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>());
// Act
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
// Assert
Assert.Null(factory);
}
[Fact]
public async Task ModelBinderFactory_BindsPropertiesOnPage()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var binder = new TestParameterBinder(new Dictionary<string, object>
{
{ nameof(PageWithProperty.Id), 10 },
{ nameof(PageWithProperty.RouteDifferentValue), "route-value" }
});
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
// Act
await factory(page, null);
// Assert
Assert.Equal(10, page.Id);
Assert.Equal("route-value", page.RouteDifferentValue);
Assert.Null(page.PropertyWithNoValue);
Assert.Collection(binder.Descriptors,
descriptor =>
{
Assert.Equal(nameof(PageWithProperty.Id), descriptor.Name);
Assert.Null(descriptor.BindingInfo.BinderModelName);
Assert.Equal(BindingSource.Query, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(int), descriptor.ParameterType);
},
descriptor =>
{
Assert.Equal(nameof(PageWithProperty.RouteDifferentValue), descriptor.Name);
Assert.Equal("route-value", descriptor.BindingInfo.BinderModelName);
Assert.Equal(BindingSource.Path, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(string), descriptor.ParameterType);
},
descriptor =>
{
Assert.Equal(nameof(PageWithProperty.PropertyWithNoValue), descriptor.Name);
Assert.Null(descriptor.BindingInfo.BinderModelName);
Assert.Equal(BindingSource.Form, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(string), descriptor.ParameterType);
});
}
[Fact]
public async Task ModelBinderFactory_BindsPropertiesOnPageModel()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithProperty).GetTypeInfo(),
};
var binder = new TestParameterBinder(new Dictionary<string, object>
{
{ nameof(PageModelWithProperty.Id), 10 },
{ nameof(PageModelWithProperty.RouteDifferentValue), "route-value" }
});
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
var model = new PageModelWithProperty();
// Act
await factory(page, model);
// Assert
// Verify that the page properties were not bound.
Assert.Equal(default(int), page.Id);
Assert.Null(page.RouteDifferentValue);
Assert.Equal(10, model.Id);
Assert.Equal("route-value", model.RouteDifferentValue);
Assert.Null(model.PropertyWithNoValue);
Assert.Collection(binder.Descriptors,
descriptor =>
{
Assert.Equal(nameof(PageModelWithProperty.Id), descriptor.Name);
Assert.Equal(BindingSource.Query, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(int), descriptor.ParameterType);
},
descriptor =>
{
Assert.Equal(nameof(PageModelWithProperty.RouteDifferentValue), descriptor.Name);
Assert.Equal("route-value", descriptor.BindingInfo.BinderModelName);
Assert.Equal(BindingSource.Path, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(string), descriptor.ParameterType);
},
descriptor =>
{
Assert.Equal(nameof(PageModelWithProperty.PropertyWithNoValue), descriptor.Name);
Assert.Null(descriptor.BindingInfo.BinderModelName);
Assert.Equal(BindingSource.Form, descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(string), descriptor.ParameterType);
});
}
[Fact]
public async Task ModelBinderFactory_DiscoversBinderType()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithModelBinderAttribute).GetTypeInfo(),
};
var expected = Guid.NewGuid();
var binder = new TestParameterBinder(new Dictionary<string, object>
{
{ nameof(PageModelWithModelBinderAttribute.PropertyWithBinderType), expected },
});
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
var model = new PageModelWithModelBinderAttribute();
// Act
await factory(page, model);
// Assert
Assert.Equal(expected, model.PropertyWithBinderType);
Assert.Collection(binder.Descriptors,
descriptor =>
{
Assert.Equal(nameof(PageModelWithModelBinderAttribute.PropertyWithBinderType), descriptor.Name);
Assert.Equal(BindingSource.Custom, descriptor.BindingInfo.BindingSource);
Assert.Equal(typeof(DeclarativeSecurityAction), descriptor.BindingInfo.BinderType);
Assert.Null(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(Guid), descriptor.ParameterType);
});
}
[Fact]
public async Task ModelBinderFactory_DiscoversPropertyFilter()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithPropertyFilterAttribute).GetTypeInfo(),
};
var binder = new TestParameterBinder(new Dictionary<string, object>());
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
var model = new PageModelWithPropertyFilterAttribute();
// Act
await factory(page, model);
// Assert
Assert.Collection(binder.Descriptors,
descriptor =>
{
Assert.Equal(nameof(PageModelWithPropertyFilterAttribute.PropertyWithFilter), descriptor.Name);
Assert.Null(descriptor.BindingInfo.BindingSource);
Assert.Null(descriptor.BindingInfo.BinderType);
Assert.IsType<TestPropertyFilterProvider>(descriptor.BindingInfo.PropertyFilterProvider);
Assert.Equal(typeof(object), descriptor.ParameterType);
});
}
[Fact]
public async Task ModelBinderFactory_UsesDefaultValueIfModelBindingFailed()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithDefaultValue).GetTypeInfo(),
};
var binder = new TestParameterBinder(new Dictionary<string, object>());
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
var model = new PageModelWithDefaultValue();
var defaultValue = model.PropertyWithDefaultValue;
// Act
await factory(page, model);
// Assert
Assert.Equal(defaultValue, model.PropertyWithDefaultValue);
}
[Fact]
public async Task ModelBinderFactory_OverwritesDefaultValue()
{
// Arrange
var actionDescriptor = new CompiledPageActionDescriptor
{
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = typeof(PageModelWithDefaultValue).GetTypeInfo(),
};
var expected = "not-default-value";
var binder = new TestParameterBinder(new Dictionary<string, object>
{
{ nameof(PageModelWithDefaultValue.PropertyWithDefaultValue), expected },
});
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var factory = PagePropertyBinderFactory.CreateBinder(binder, modelMetadataProvider, actionDescriptor);
var page = new PageWithProperty
{
PageContext = new PageContext(),
};
var model = new PageModelWithDefaultValue();
var defaultValue = model.PropertyWithDefaultValue;
// Act
await factory(page, model);
// Assert
Assert.Equal(expected, model.PropertyWithDefaultValue);
}
private class TestParameterBinder : ParameterBinder
{
private readonly IDictionary<string, object> _args;
public TestParameterBinder(IDictionary<string, object> args)
: base(
TestModelMetadataProvider.CreateDefaultProvider(),
TestModelBinderFactory.CreateDefault(),
Mock.Of<IObjectModelValidator>())
{
_args = args;
}
public IList<ParameterDescriptor> Descriptors { get; } = new List<ParameterDescriptor>();
public override Task<ModelBindingResult> BindModelAsync(ActionContext actionContext, IValueProvider valueProvider, ParameterDescriptor parameter, object value)
{
Descriptors.Add(parameter);
if (_args.TryGetValue(parameter.Name, out var result))
{
return Task.FromResult(ModelBindingResult.Success(result));
}
return Task.FromResult(ModelBindingResult.Failed());
}
}
private class PageModelWithNoBoundProperties : PageModel
{
}
private class PageWithNoBoundProperties : Page
{
public override Task ExecuteAsync() => Task.FromResult(0);
}
private class PageWithNoVisibleBoundProperties : Page
{
[FromBody]
private string FromBody { get; set; }
[FromQuery]
protected string FromQuery { get; set; }
[FromRoute]
public static int FromRoute { get; set; }
public override Task ExecuteAsync() => Task.FromResult(0);
}
private class PageModelWithNoVisibleBoundProperties : PageModel
{
[FromBody]
private string FromBody { get; set; }
[FromQuery]
protected string FromQuery { get; set; }
[FromRoute]
public static int FromRoute { get; set; }
}
private class PageWithReadOnlyProperties : Page
{
[FromBody]
private string FromBody { get; }
public override Task ExecuteAsync() => Task.FromResult(0);
}
private class PageModelWithReadOnlyProperties
{
[FromBody]
private string FromBody { get; }
}
private class PageWithProperty : Page
{
[FromQuery]
public int Id { get; set; }
[FromRoute(Name = "route-value")]
public string RouteDifferentValue { get; set; }
[FromForm]
public string PropertyWithNoValue { get; set; }
public override Task ExecuteAsync() => Task.FromResult(0);
}
private class PageModelWithProperty : PageModel
{
[FromQuery]
public int Id { get; set; }
[FromRoute(Name = "route-value")]
public string RouteDifferentValue { get; set; }
[FromForm]
public string PropertyWithNoValue { get; set; }
}
private class PageModelWithModelBinderAttribute
{
[ModelBinder(BinderType = typeof(DeclarativeSecurityAction))]
public Guid PropertyWithBinderType { get; set; }
}
private class PageModelWithPropertyFilterAttribute
{
[ModelBinder]
[TestPropertyFilterProvider]
public object PropertyWithFilter { get; set; }
}
private class TestPropertyFilterProvider : Attribute, IPropertyFilterProvider
{
public Func<ModelMetadata, bool> PropertyFilter => _ => true;
}
private class PageModelWithDefaultValue
{
[ModelBinder]
public string PropertyWithDefaultValue { get; set; } = "Hello world";
}
}
}

16
test/WebSites/RazorPagesWebSite/Models/UserModel.cs Normal file
View File

@ -0,0 +1,16 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.ComponentModel.DataAnnotations;
namespace RazorPagesWebSite
{
public class UserModel
{
[Required]
public string Name { get; set; }
[Range(0, 99)]
public int Age { get; set; }
}
}

26
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/PageModelWithPropertyAndArgumentBinding.cs Normal file
View File

@ -0,0 +1,26 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace RazorPagesWebSite
{
public class PageModelWithPropertyAndArgumentBinding : PageModel
{
[ModelBinder]
public UserModel UserModel { get; set; }
public int Id { get; set; }
public void OnGet(int id)
{
Id = id;
}
public void OnPost(int id)
{
Id = id;
}
}
}

17
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/PageModelWithPropertyBinding.cs Normal file
View File

@ -0,0 +1,17 @@
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
namespace RazorPagesWebSite
{
public class PageModelWithPropertyBinding : PageModel
{
[ModelBinder]
public UserModel UserModel { get; set; }
[FromRoute]
public int Id { get; set; }
}
}

8
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/PageModelWithPropertyBinding.cshtml Normal file
View File

@ -0,0 +1,8 @@
@page "{id:int}"
@model PageModelWithPropertyBinding
Id = @Model.Id, Name = @Model.UserModel?.Name, Age = @Model.UserModel?.Age
@Html.ValidationSummary()
<form action="">
@Html.AntiForgeryToken()
</form>

14
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/PagePropertyBinding.cshtml Normal file
View File

@ -0,0 +1,14 @@
@page "{id:int}"
@functions
{
[ModelBinder]
public UserModel UserModel { get; set; }
[FromRoute]
public int Id { get; set; }
}
Id = @Id, Name = @UserModel?.Name, Age = @UserModel?.Age
@Html.ValidationSummary()
<form action="">
@Html.AntiForgeryToken()
</form>

8
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/PageWithPropertyAndArgumentBinding.cshtml Normal file
View File

@ -0,0 +1,8 @@
@page
@model PageModelWithPropertyAndArgumentBinding
Id = @Model.Id, Name = @Model.UserModel?.Name, Age = @Model.UserModel?.Age
@Html.ValidationSummary()
<form action="">
@Html.AntiForgeryToken()
</form>

1
test/WebSites/RazorPagesWebSite/Pages/PropertyBinding/_PageImports.cshtml Normal file
View File

@ -0,0 +1 @@
@using RazorPagesWebSite