public void BuildParameters_String(string value, string bindingType)
{
var binding = ParameterBinder.BuildParameterBindings(value);
Assert.AreEqual(1, binding.Count);
Assert.IsTrue(binding.ContainsKey("1"));
Assert.AreEqual(bindingType, binding["1"].Type);
Assert.AreEqual(value, binding["1"].Value);
}
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));
}
public void ShouldNotVisitInvocationLambda()
{
var parameter = Expression.Parameter(typeof(Func <bool, bool>));
var replacement = Expression.Parameter(typeof(Func <bool, bool>));
var result = new ParameterBinder(parameter, replacement).Visit(Expression.Invoke(parameter, Expression.Parameter(typeof(bool))));
Assert.NotEqual(ExpressionType.Constant, result.NodeType);
}
public void When1LevelParamWithCollection_CanConvertTheCollection()
{
var p = new ParameterBinder(typeof(Aclass), "MethodOneLevelColl", new NameValueCollection { { "P1", "123" }, { "P2", "452" }, { "Coll", "8" }, { "Coll", "9" } });
var instance = new Aclass();
p.Invoke(instance);
instance.OneLevelColl.P1.Should().Be.EqualTo(123);
instance.OneLevelColl.Coll.Should().Have.SameValuesAs(8, 9);
}
public void ShouldNotVisitParameter()
{
var parameter = Expression.Parameter(typeof(bool));
var replacement = Expression.Constant(true);
var result = new ParameterBinder(Expression.Parameter(typeof(bool)), replacement).Visit(parameter);
Assert.Equal(parameter, result);
}
public void When2LevelParam_ChooseMethodWith2Param()
{
var p = new ParameterBinder(typeof(Aclass), "MethodTwoLevel", new NameValueCollection { { "Simple1Level.P1", "123" }, { "Simple1Level.P2", "452" } });
var instance = new Aclass();
p.Invoke(instance);
instance.TwoLevel.Simple1Level.P1.Should().Be.EqualTo(123);
instance.TwoLevel.Simple1Level.P2.Should().Be.EqualTo(452);
}
public void BuildParameters_BytesArray(byte[] value, string expectedString, string bindingType)
{
var binding = ParameterBinder.BuildParameterBindings(value);
Assert.AreEqual(1, binding.Count);
Assert.IsTrue(binding.ContainsKey("1"));
Assert.AreEqual(bindingType, binding["1"].Type);
Assert.AreEqual(expectedString, binding["1"].Value);
}
public async Task BindModelAsync_ForOverlappingParametersWithSuppressions_InValid_WithValidSecondParameter()
{
// Arrange
var parameterDescriptor = new ParameterDescriptor
{
Name = "patchDocument",
ParameterType = typeof(IJsonPatchDocument),
};
var actionContext = GetControllerContext();
var modelState = actionContext.ModelState;
// First ModelState key is not empty to match SimpleTypeModelBinder.
modelState.SetModelValue("id", "notAGuid", "notAGuid");
modelState.AddModelError("id", "This is not valid.");
var modelMetadataProvider = new TestModelMetadataProvider();
modelMetadataProvider.ForType <IJsonPatchDocument>().ValidationDetails(v => v.ValidateChildren = false);
var modelMetadata = modelMetadataProvider.GetMetadataForType(typeof(IJsonPatchDocument));
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
// BodyModelBinder does not update ModelState in success case.
var modelBindingResult = ModelBindingResult.Success(new JsonPatchDocument());
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
new SimpleValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.False(modelState.IsValid);
Assert.Collection(
modelState,
kvp =>
{
Assert.Equal("id", kvp.Key);
Assert.Equal(ModelValidationState.Invalid, kvp.Value.ValidationState);
var error = Assert.Single(kvp.Value.Errors);
Assert.Equal("This is not valid.", error.ErrorMessage);
});
}
public void When2Params_InvokeMethodWithCorrectParamsValues()
{
var p = new ParameterBinder(typeof(MyClass), "A", new NameValueCollection { { "p1", "123" }, { "p2", "452" } });
var instance = new MyClass();
p.Invoke(instance);
instance.P1.Should().Be.EqualTo(123);
instance.P2.Should().Be.EqualTo(452);
}
public async Task CreatePropertyBinder_ValidatesTopLevelProperties()
{
// Arrange
var type = typeof(PageModelWithValidation).GetTypeInfo();
var actionDescriptor = new CompiledPageActionDescriptor
{
BoundProperties = new[]
{
new PageBoundPropertyDescriptor()
{
Name = nameof(PageModelWithValidation.Validated),
ParameterType = typeof(string),
Property = type.GetProperty(nameof(PageModelWithValidation.Validated)),
},
},
HandlerTypeInfo = type,
PageTypeInfo = typeof(PageWithProperty).GetTypeInfo(),
ModelTypeInfo = type,
};
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var modelBinderFactory = TestModelBinderFactory.CreateDefault();
var binder = new ParameterBinder(
modelMetadataProvider,
modelBinderFactory,
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() }),
NullLoggerFactory.Instance);
var factory = PageBinderFactory.CreatePropertyBinder(binder, modelMetadataProvider, modelBinderFactory, actionDescriptor);
var page = new PageWithProperty
{
PageContext = GetPageContext()
};
var model = new PageModelWithValidation();
// Act
await factory(page.PageContext, model);
// Assert
var modelState = page.PageContext.ModelState;
Assert.False(modelState.IsValid);
Assert.Collection(
modelState,
kvp =>
{
Assert.Equal(nameof(PageModelWithValidation.Validated), kvp.Key);
});
}
public ParameterBindingRouteConstraint(ParameterBinder binder)
: base(binder.ParameterType)
{
if (binder == null)
{
throw new ArgumentNullException("binder");
}
_Binder = binder;
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. All arguments
/// are treated as positional arguments.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args)
{
return(CallMethod(
parameterBinder,
targets,
args,
new CallSignature(args.Count),
Restrictions.Empty
));
}
public MyControllerActionInvokerCache(
IActionDescriptorCollectionProvider collectionProvider,
ParameterBinder parameterBinder,
IModelBinderFactory modelBinderFactory,
IModelMetadataProvider modelMetadataProvider,
IEnumerable <IFilterProvider> filterProviders,
IControllerFactoryProvider factoryProvider,
IOptions <MvcOptions> mvcOptions) : base(collectionProvider, parameterBinder, modelBinderFactory, modelMetadataProvider, filterProviders, factoryProvider, mvcOptions)
{
}
public async Task BindModelAsync_ForParameter_UsesValidationFromParameter_WhenDerivedModelIsSet()
{
// Arrange
var method = GetType().GetMethod(nameof(TestMethodWithAttributes), BindingFlags.NonPublic | BindingFlags.Instance);
var parameter = method.GetParameters()[0];
var parameterDescriptor = new ControllerParameterDescriptor
{
ParameterInfo = parameter,
Name = parameter.Name,
};
var actionContext = GetControllerContext();
var modelMetadataProvider = new TestModelMetadataProvider();
var model = new DerivedPerson {
DerivedProperty = "SomeValue"
};
var modelBindingResult = ModelBindingResult.Success(model);
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
var modelMetadata = modelMetadataProvider.GetMetadataForParameter(parameter);
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
CreateMockValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.Same(model, result.Model);
Assert.False(actionContext.ModelState.IsValid);
Assert.Collection(
actionContext.ModelState,
kvp =>
{
Assert.Equal(parameter.Name, kvp.Key);
var error = Assert.Single(kvp.Value.Errors);
Assert.Equal("Always Invalid", error.ErrorMessage);
});
}
public async Task BindModelAsync_ForProperty_UsesValidationOnProperty_WhenDerivedModelIsSet()
{
// Arrange
var property = typeof(TestControllerWithValidatedProperties).GetProperty(nameof(TestControllerWithValidatedProperties.Model));
var parameterDescriptor = new ControllerBoundPropertyDescriptor
{
PropertyInfo = property,
Name = property.Name,
};
var actionContext = GetControllerContext();
var modelMetadataProvider = new TestModelMetadataProvider();
var model = new DerivedModel {
DerivedProperty = "some value"
};
var modelBindingResult = ModelBindingResult.Success(model);
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
var modelMetadata = modelMetadataProvider.GetMetadataForProperty(property.DeclaringType, property.Name);
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
CreateMockValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.Same(model, result.Model);
Assert.False(actionContext.ModelState.IsValid);
Assert.Collection(
actionContext.ModelState,
kvp =>
{
Assert.Equal($"{property.Name}", kvp.Key);
var error = Assert.Single(kvp.Value.Errors);
Assert.Equal("Always Invalid", error.ErrorMessage);
});
}
private FormReader CreateReader(RequestGraph requestGraph)
{
var parameterBinder = new ParameterBinder <ReadResult>(
requestGraph.Configuration,
requestGraph.HttpConfiguration,
requestGraph.ActionMethod,
requestGraph.GetRouteDescriptor(),
requestGraph.ValueMappers);
return(new FormReader(parameterBinder, requestGraph.ActionMethod));
}
public void BuildParameters_DateTime(string stringValue, string expectedString, string bindingType)
{
var value = DateTime.ParseExact(stringValue, "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
var binding = ParameterBinder.BuildParameterBindings(value);
Assert.AreEqual(1, binding.Count);
Assert.IsTrue(binding.ContainsKey("1"));
Assert.AreEqual(bindingType, binding["1"].Type);
Assert.AreEqual(expectedString, binding["1"].Value);
}
public async Task BindModelAsync_ForOverlappingParameters_InValid_WithInValidFirstParameterAndSecondNull()
{
// Arrange
var parameterDescriptor = new ParameterDescriptor
{
BindingInfo = new BindingInfo
{
BinderModelName = "id",
},
Name = "identifier",
ParameterType = typeof(string),
};
var actionContext = GetControllerContext();
var modelState = actionContext.ModelState;
// Mimic ModelStateEntry when first parameter is [FromRoute] int id and request URI is /api/values/notAnInt
modelState.SetModelValue("id", "notAnInt", "notAnInt");
modelState.AddModelError("id", "This is not valid.");
var modelMetadataProvider = new TestModelMetadataProvider();
var modelMetadata = modelMetadataProvider.GetMetadataForType(typeof(string));
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
// Mimic result when second parameter is [FromQuery(Name = "id")] string identifier and query is ?id
var modelBindingResult = ModelBindingResult.Success(null);
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
new SimpleValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.False(modelState.IsValid);
var keyValuePair = Assert.Single(modelState);
Assert.Equal("id", keyValuePair.Key);
Assert.Equal(ModelValidationState.Invalid, keyValuePair.Value.ValidationState);
}
private static PageActionInvokerProvider CreateInvokerProvider(
IPageLoader loader,
IActionDescriptorCollectionProvider actionDescriptorProvider,
IPageFactoryProvider pageProvider = null,
IPageModelFactoryProvider modelProvider = null,
IRazorPageFactoryProvider razorPageFactoryProvider = null,
RazorProjectFileSystem fileSystem = null)
{
var tempDataFactory = new Mock <ITempDataDictionaryFactory>();
tempDataFactory
.Setup(t => t.GetTempData(It.IsAny <HttpContext>()))
.Returns((HttpContext context) => new TempDataDictionary(context, Mock.Of <ITempDataProvider>()));
if (fileSystem == null)
{
fileSystem = Mock.Of <RazorProjectFileSystem>();
}
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var modelBinderFactory = TestModelBinderFactory.CreateDefault();
var mvcOptions = new MvcOptions
{
AllowValidatingTopLevelNodes = true,
};
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
TestModelBinderFactory.CreateDefault(),
Mock.Of <IObjectModelValidator>(),
Options.Create(mvcOptions),
NullLoggerFactory.Instance);
return(new PageActionInvokerProvider(
loader,
pageProvider ?? Mock.Of <IPageFactoryProvider>(),
modelProvider ?? Mock.Of <IPageModelFactoryProvider>(),
razorPageFactoryProvider ?? Mock.Of <IRazorPageFactoryProvider>(),
actionDescriptorProvider,
new IFilterProvider[0],
parameterBinder,
modelMetadataProvider,
modelBinderFactory,
tempDataFactory.Object,
Options.Create(new MvcOptions()),
Options.Create(new HtmlHelperOptions()),
Mock.Of <IPageHandlerMethodSelector>(),
fileSystem,
new DiagnosticListener("Microsoft.AspNetCore"),
NullLoggerFactory.Instance,
new ActionResultTypeMapper()));
}
public ActionDisambiguatorForOverloadedMethods(
IModelBinderFactory modelBinderFactory,
IModelMetadataProvider modelMetadataProvider,
MvcOptions mvcOptions,
ParameterBinder parameterBinder,
ScoreSignature scoreDelegate = null)
{
this.modelBinderFactory = modelBinderFactory;
this.modelMetadataProvider = modelMetadataProvider;
this.mvcOptions = mvcOptions;
this.parameterBinder = parameterBinder;
this.scoreDelegate = scoreDelegate ?? Score;
}
public void BuildParameters_Numeric(object objectValue, Type type, string bindingType)
{
var value = Convert.ChangeType(objectValue, type);
var binding = ParameterBinder.BuildParameterBindings(value);
Assert.AreEqual(1, binding.Count);
Assert.IsTrue(binding.ContainsKey("1"));
Assert.AreEqual(bindingType, binding["1"].Type);
var stringValue = string.Format(CultureInfo.InvariantCulture, "{0}", objectValue);
Assert.AreEqual(stringValue, binding["1"].Value);
}
public void BuildParameters_Guid()
{
var guid = Guid.NewGuid();
var binding = ParameterBinder.BuildParameterBindings(guid);
var stringValue = string.Format(CultureInfo.InvariantCulture, "{0}", guid);
Assert.AreEqual(1, binding.Count);
Assert.IsTrue(binding.ContainsKey("1"));
Assert.AreEqual("TEXT", binding["1"].Type);
Assert.AreEqual(stringValue, binding["1"].Value);
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. All arguments
/// are treated as positional arguments.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, NarrowingLevel minLevel, NarrowingLevel maxLevel)
{
return(CallWorker(
parameterBinder,
targets,
args,
new CallSignature(args.Count),
CallTypes.None,
Restrictions.Empty,
minLevel,
maxLevel,
null
));
}
public void BuildParameters_FromAnonymousType()
{
var value = new { IntProperty = 2, StringProperty = "test" };
var bindings = ParameterBinder.BuildParameterBindings(value);
Assert.IsTrue(bindings.ContainsKey(nameof(value.IntProperty)));
Assert.IsTrue(bindings[nameof(value.IntProperty)].Type == "FIXED");
Assert.IsTrue(bindings[nameof(value.IntProperty)].Value == value.IntProperty.ToString());
Assert.IsTrue(bindings.ContainsKey(nameof(value.StringProperty)));
Assert.IsTrue(bindings[nameof(value.StringProperty)].Type == "TEXT");
Assert.IsTrue(bindings[nameof(value.StringProperty)].Value == value.StringProperty);
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. The arguments are
/// consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <param name="name">The name of the method or null to use the name from targets.</param>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, Restrictions restrictions, string name)
{
return(CallWorker(
parameterBinder,
targets,
args,
signature,
CallTypes.None,
restrictions,
NarrowingLevel.None,
NarrowingLevel.All,
name
));
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments. The arguments are
/// consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="target">The resulting binding target which can be used for producing error information.</param>
/// <param name="name">The name of the method or null to use the name from targets.</param>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, IList <MetaObject> args, CallSignature signature, Restrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target)
{
return(CallWorker(
parameterBinder,
targets,
args,
signature,
CallTypes.None,
restrictions,
minLevel,
maxLevel,
name,
out target
));
}
public ControllerActionInvokerCache(
ParameterBinder parameterBinder,
IModelBinderFactory modelBinderFactory,
IModelMetadataProvider modelMetadataProvider,
IEnumerable <IFilterProvider> filterProviders,
IControllerFactoryProvider factoryProvider,
IOptions <MvcOptions> mvcOptions)
{
_parameterBinder = parameterBinder;
_modelBinderFactory = modelBinderFactory;
_modelMetadataProvider = modelMetadataProvider;
_filterProviders = filterProviders.OrderBy(item => item.Order).ToArray();
_controllerFactoryProvider = factoryProvider;
_mvcOptions = mvcOptions.Value;
}
public ControllerActionInvokerCache(
IActionDescriptorCollectionProvider collectionProvider,
ParameterBinder parameterBinder,
IModelBinderFactory modelBinderFactory,
IModelMetadataProvider modelMetadataProvider,
IEnumerable <IFilterProvider> filterProviders,
IControllerFactoryProvider factoryProvider)
{
_collectionProvider = collectionProvider;
_parameterBinder = parameterBinder;
_modelBinderFactory = modelBinderFactory;
_modelMetadataProvider = modelMetadataProvider;
_filterProviders = filterProviders.OrderBy(item => item.Order).ToArray();
_controllerFactoryProvider = factoryProvider;
}
/// <summary>
/// Performs binding against a set of overloaded methods using the specified arguments and the specified
/// instance argument. The arguments are consumed as specified by the CallSignature object.
/// </summary>
/// <param name="parameterBinder">ParameterBinder used to map arguments to parameters.</param>
/// <param name="targets">The methods to be called</param>
/// <param name="args">The arguments for the call</param>
/// <param name="signature">The call signature which specified how the arguments will be consumed</param>
/// <param name="restrictions">Additional restrictions which should be applied to the resulting MetaObject.</param>
/// <param name="instance">The instance which will be provided for dispatching to an instance method.</param>
/// <param name="maxLevel">The maximum narrowing level for arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="minLevel">The minimum narrowing level for the arguments. The current narrowing level is flowed thorugh to the DefaultBinder.</param>
/// <param name="target">The resulting binding target which can be used for producing error information.</param>
/// <param name="name">The name of the method or null to use the name from targets.</param>
/// <returns>A meta object which results from the call.</returns>
public MetaObject CallInstanceMethod(ParameterBinder parameterBinder, IList <MethodBase> targets, MetaObject instance, IList <MetaObject> args, CallSignature signature, Restrictions restrictions, NarrowingLevel minLevel, NarrowingLevel maxLevel, string name, out BindingTarget target)
{
return(CallWorker(
parameterBinder,
targets,
ArrayUtils.Insert(instance, args),
signature,
CallTypes.ImplicitInstance,
restrictions,
minLevel,
maxLevel,
name,
out target
));
}
public async Task CreateHandlerBinder_ValidatesTopLevelParameters()
{
// Arrange
var type = typeof(PageModelWithExecutors);
var actionDescriptor = GetActionDescriptorWithHandlerMethod(type, nameof(PageModelWithExecutors.OnPostWithValidation));
// Act
var modelMetadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var modelBinderFactory = TestModelBinderFactory.CreateDefault();
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
modelBinderFactory,
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() }),
NullLoggerFactory.Instance);
var factory = PageBinderFactory.CreateHandlerBinder(
parameterBinder,
modelMetadataProvider,
modelBinderFactory,
actionDescriptor,
actionDescriptor.HandlerMethods[0]);
var page = new PageWithProperty
{
PageContext = GetPageContext()
};
var model = new PageModelWithExecutors();
var arguments = new Dictionary <string, object>();
// Act
await factory(page.PageContext, arguments);
// Assert
var modelState = page.PageContext.ModelState;
Assert.False(modelState.IsValid);
Assert.Collection(
page.PageContext.ModelState,
kvp =>
{
Assert.Equal("name", kvp.Key);
});
}
private TotemNameBinder(CompilerContext context)
{
_define = new DefineBinder(this);
_parameter = new ParameterBinder(this);
_context = context;
}
