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; }