public void Construct(IProxyFactory proxyFactory)
{
AlternateType <IModelBinderProvider> sut = new ModelBinderProvider(proxyFactory);
Assert.NotNull(sut);
Assert.IsAssignableFrom <AlternateType <IModelBinderProvider> >(sut);
}
private static bool TryGetProviderFromAttributes(Type modelType, out ModelBinderProvider provider)
{
ModelBinderAttribute attr = TypeDescriptorHelper.Get(modelType).GetAttributes().OfType <ModelBinderAttribute>().FirstOrDefault();
if (attr == null)
{
provider = null;
return(false);
}
// TODO, 386718, remove the following if statement when the bug is resolved
if (attr.BinderType == null)
{
provider = null;
return(false);
}
if (typeof(ModelBinderProvider).IsAssignableFrom(attr.BinderType))
{
provider = (ModelBinderProvider)Activator.CreateInstance(attr.BinderType);
}
else
{
throw Error.InvalidOperation(SRResources.ModelBinderProviderCollection_InvalidBinderType, attr.BinderType.Name, typeof(ModelBinderProvider).Name, typeof(IModelBinder).Name);
}
return(true);
}
public void Construct(IProxyFactory proxyFactory)
{
AlternateType<IModelBinderProvider> sut = new ModelBinderProvider(proxyFactory);
Assert.NotNull(sut);
Assert.IsAssignableFrom<AlternateType<IModelBinderProvider>>(sut);
}
public async Task BindModel_CallsBindAsync_OnProvidedModelBinderProvider()
{
// Arrange
var bindingContext = GetBindingContext(typeof(Person));
bindingContext.ModelMetadata.BinderType = typeof(ModelBinderProvider);
var model = new Person();
var innerModelBinder = new TrueModelBinder(model);
var provider = new ModelBinderProvider(innerModelBinder);
var mockITypeActivator = new Mock <ITypeActivator>();
mockITypeActivator
.Setup(o => o.CreateInstance(It.IsAny <IServiceProvider>(), typeof(ModelBinderProvider)))
.Returns(provider);
var binder = new BinderTypeBasedModelBinder(mockITypeActivator.Object);
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(binderResult);
Assert.Same(model, bindingContext.Model);
}
public async Task BindModel_CallsBindAsync_OnProvidedModelBinderProvider()
{
// Arrange
var bindingContext = GetBindingContext(typeof(Person), binderType: typeof(ModelBinderProvider));
var model = new Person();
var provider = new ModelBinderProvider();
var serviceProvider = new ServiceCollection()
.AddSingleton(typeof(IModelBinderProvider))
.AddSingleton(typeof(IModelBinder))
.BuildServiceProvider();
bindingContext.OperationBindingContext.HttpContext.RequestServices = serviceProvider;
var binder = new BinderTypeBasedModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
var p = (Person)binderResult.Model;
Assert.Equal(model.Age, p.Age);
Assert.Equal(model.Name, p.Name);
}
public void ProceedAndReturnWithRuntimePolicyOff(ModelBinderProvider.GetBinder sut, IAlternateMethodContext context)
{
context.Setup(c => c.RuntimePolicyStrategy).Returns(() => RuntimePolicy.Off);
sut.NewImplementation(context);
context.Verify(c => c.Proceed());
context.MessageBroker.Verify(mb => mb.Publish(It.IsAny<object>()), Times.Never());
}
private HttpParameterBinding DetermineBinding(HttpParameterDescriptor parameter)
{
HttpConfiguration config = parameter.Configuration;
var attr = new ModelBinderAttribute(); // use default settings
ModelBinderProvider provider = attr.GetModelBinderProvider(config);
IModelBinder binder = provider.GetBinder(config, parameter.ParameterType);
// Alternatively, we could put this ValueProviderFactory in the global config.
var valueProviderFactories = new List<ValueProviderFactory>(attr.GetValueProviderFactories(config)) { new BodyValueProviderFactory() };
return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories);
}
public void ListWrappingConstructor()
{
// Arrange
ModelBinderProvider[] providers = new ModelBinderProvider[] {
new Mock <ModelBinderProvider>().Object,
new Mock <ModelBinderProvider>().Object
};
// Act
ModelBinderProviderCollection collection = new ModelBinderProviderCollection(providers);
// Assert
CollectionAssert.AreEqual(providers, collection);
}
private void BinderType_From_DependencyResolver_Impl(IDependencyResolver resolver)
{
// To test dependency resolver, the registered type and actual type should be different.
HttpConfiguration config = new HttpConfiguration();
var mockDependencyResolver = new Mock <IDependencyResolver>();
mockDependencyResolver.Setup(r => r.GetService(typeof(CustomModelBinderProvider))).Returns(new SecondCustomModelBinderProvider());
config.DependencyResolver = mockDependencyResolver.Object;
ModelBinderAttribute attr = new ModelBinderAttribute(typeof(CustomModelBinderProvider));
ModelBinderProvider provider = attr.GetModelBinderProvider(config);
Assert.IsType <SecondCustomModelBinderProvider>(provider);
}
public static string ModelBinderToString(ModelBinderProvider provider)
{
Contract.Assert(provider != null);
CompositeModelBinderProvider composite = provider as CompositeModelBinderProvider;
if (composite == null)
{
return(provider.GetType().Name);
}
string modelBinderList = string.Join(", ", composite.Providers.Select <ModelBinderProvider, string>(ModelBinderToString));
return(provider.GetType().Name + "(" + modelBinderList + ")");
}
public async Task BindModel_CallsBindAsync_OnProvidedModelBinderProvider()
{
// Arrange
var bindingContext = GetBindingContext(typeof(Person), binderType: typeof(ModelBinderProvider));
var model = new Person();
var provider = new ModelBinderProvider();
var serviceProvider = new ServiceCollection()
.AddSingleton(typeof(IModelBinderProvider))
.AddSingleton(typeof(IModelBinder))
.BuildServiceProvider();
bindingContext.OperationBindingContext.HttpContext.RequestServices = serviceProvider;
var binder = new BinderTypeBasedModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
var p = (Person)binderResult.Model;
Assert.Equal(model.Age, p.Age);
Assert.Equal(model.Name, p.Name);
}
private void SetupModelBinderProviders(IInspectorContext context)
{
#if !MVC2
var binderProviders = ModelBinderProviders.BinderProviders;
if (binderProviders.Count == 0)
{
return;
}
var alternateModelBinderProvider = new ModelBinderProvider(context.ProxyFactory);
for (int i = 0; i < binderProviders.Count; i++)
{
var originalBinder = binderProviders[i];
IModelBinderProvider newProvider;
if (alternateModelBinderProvider.TryCreate(originalBinder, out newProvider))
{
context.Logger.Info(Resources.ModelBinderInspectorSetupReplacedModelBinderProvider, originalBinder.GetType());
binderProviders[i] = newProvider;
}
}
#endif
}
private void SetupModelBinderProviders(IInspectorContext context)
{
#if !MVC2
var binderProviders = ModelBinderProviders.BinderProviders;
if (binderProviders.Count == 0)
{
return;
}
var alternateModelBinderProvider = new ModelBinderProvider(context.ProxyFactory);
for (int i = 0; i < binderProviders.Count; i++)
{
var originalBinder = binderProviders[i];
IModelBinderProvider newProvider;
if (alternateModelBinderProvider.TryCreate(originalBinder, out newProvider))
{
context.Logger.Info(Resources.ModelBinderInspectorSetupReplacedModelBinderProvider, originalBinder.GetType());
binderProviders[i] = newProvider;
}
}
#endif
}
public void ImplementProperMethod(ModelBinderProvider.GetBinder sut)
{
Assert.Equal("GetBinder", sut.MethodToImplement.Name);
}
public CompositeModelBinder(ModelBinderProvider[] modelBinderProviders)
{
Providers = modelBinderProviders;
}
public void ImplementOneMethod(ModelBinderProvider sut)
{
Assert.Equal(1, sut.AllMethods.Count());
}
/// <summary>
/// Deserialize the form data to the given type, using model binding.
/// </summary>
/// <param name="formData">collection with parsed form url data</param>
/// <param name="type">target type to read as</param>
/// <param name="modelName">null or empty to read the entire form as a single object. This is common for body data.
/// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> used to determine required members.</param>
/// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
/// Or the name of a model to do a partial binding against the form data. This is common for extracting individual fields.</param>
/// <returns>best attempt to bind the object. The best attempt may be null.</returns>
public static object FixedReadAs(this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger)
{
if (formData == null)
{
throw Error.ArgumentNull("formData");
}
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (modelName == null)
{
modelName = string.Empty;
}
using (HttpConfiguration config = new HttpConfiguration())
{
bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null;
if (validateRequiredMembers)
{
// Set a ModelValidatorProvider that understands the IRequiredMemberSelector
config.Services.Replace(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(requiredMemberSelector));
}
// Looks like HttpActionContext is just a way of getting to the config, which we really
// just need to get a list of modelbinderPRoviders for composition.
HttpActionContext actionContext = CreateActionContextForModelBinding(config);
IValueProvider vp = formData.GetJQueryValueProvider();
ModelBindingContext ctx = CreateModelBindingContext(actionContext, modelName, type, vp);
ModelBinderProvider modelBinderProvider = CreateModelBindingProvider(actionContext);
IModelBinder binder = modelBinderProvider.GetBinder(config, type);
bool haveResult = binder.BindModel(actionContext, ctx);
// Log model binding errors
if (formatterLogger != null)
{
foreach (KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState)
{
foreach (ModelError modelError in modelStatePair.Value.Errors)
{
if (modelError.Exception != null)
{
formatterLogger.LogError(modelStatePair.Key, modelError.Exception);
}
else
{
formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage);
}
}
}
}
if (haveResult)
{
return(ctx.Model);
}
return(MediaTypeFormatter.GetDefaultValueForType(type));
}
}
public ModelBinderProviderTests()
{
this.context = new Mock <ModelBinderProviderContext>();
this.binder = new Mock <IModelBinder>();
this.subject = new ModelBinderProvider <string>(this.binder.Object);
}
public void ImplementOneMethod(ModelBinderProvider sut)
{
Assert.Equal(1, sut.AllMethods.Count());
}
private static bool TryGetProviderFromAttributes(Type modelType, out ModelBinderProvider provider)
{
ModelBinderAttribute attr = TypeDescriptorHelper.Get(modelType).GetAttributes().OfType<ModelBinderAttribute>().FirstOrDefault();
if (attr == null)
{
provider = null;
return false;
}
// TODO, 386718, remove the following if statement when the bug is resolved
if (attr.BinderType == null)
{
provider = null;
return false;
}
if (typeof(ModelBinderProvider).IsAssignableFrom(attr.BinderType))
{
provider = (ModelBinderProvider)Activator.CreateInstance(attr.BinderType);
}
else
{
throw Error.InvalidOperation(SRResources.ModelBinderProviderCollection_InvalidBinderType, attr.BinderType.Name, typeof(ModelBinderProvider).Name, typeof(IModelBinder).Name);
}
return true;
}
