public void GetBinderReturnsValueFromFirstSuccessfulBinderProvider()
{
// Arrange
var testType = typeof(string);
IModelBinder nullModelBinder = null;
IModelBinder expectedBinder = new Mock<IModelBinder>().Object;
IModelBinder secondMatchingBinder = new Mock<IModelBinder>().Object;
var provider1 = new Mock<IModelBinderProvider>();
provider1.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);
var provider2 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
provider2.Setup(p => p.GetBinder(testType)).Returns(expectedBinder);
var provider3 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
provider3.Setup(p => p.GetBinder(testType)).Returns(secondMatchingBinder);
var collection = new ModelBinderProviderCollection(new[] { provider1.Object, provider2.Object, provider3.Object });
// Act
IModelBinder returnedBinder = collection.GetBinder(testType);
// Assert
Assert.Same(expectedBinder, returnedBinder);
}
public void GuardClause()
{
// Arrange
var collection = new ModelBinderProviderCollection();
// Act & Assert
Assert.ThrowsArgumentNull(
() => collection.GetBinder(null),
"modelType"
);
}
public void GuardClause() {
//Arrange
var collection = new ModelBinderProviderCollection();
//Act & Assert
ExceptionHelper.ExpectArgumentNullException(
() => collection.GetBinder(null),
"modelType"
);
}
public void GetBinderUsesRegisteredProviders() {
//Arrange
var testType = typeof(string);
var expectedBinder = new Mock<IModelBinder>().Object;
var provider = new Mock<IModelBinderProvider>(MockBehavior.Strict);
provider.Setup(p => p.GetBinder(testType)).Returns(expectedBinder);
var collection = new ModelBinderProviderCollection(new[] { provider.Object });
//Act
IModelBinder returnedBinder = collection.GetBinder(testType);
//Assert
Assert.AreSame(expectedBinder, returnedBinder);
}
public void Initialize_ReplacesOriginalCollection() {
// Arrange
ModelBinderDictionary oldBinders = new ModelBinderDictionary();
oldBinders[typeof(int)] = new Mock<IModelBinder>().Object;
ModelBinderProviderCollection newBinderProviders = new ModelBinderProviderCollection();
// Act
ModelBinderConfig.Initialize(oldBinders, newBinderProviders);
// Assert
Assert.AreEqual(0, oldBinders.Count, "Old binder dictionary should have been cleared.");
ExtensibleModelBinderAdapter shimBinder = oldBinders.DefaultBinder as ExtensibleModelBinderAdapter;
Assert.IsNotNull(shimBinder, "The default binder for the old system should have been replaced with a compatibility shim.");
Assert.AreSame(newBinderProviders, shimBinder.Providers, "Providers collection was not passed through correctly.");
}
public void Initialize_ReplacesOriginalCollection()
{
// Arrange
ModelBinderDictionary oldBinders = new ModelBinderDictionary();
oldBinders[typeof(int)] = new Mock<IModelBinder>().Object;
ModelBinderProviderCollection newBinderProviders = new ModelBinderProviderCollection();
// Act
ModelBinderConfig.Initialize(oldBinders, newBinderProviders);
// Assert
Assert.Empty(oldBinders);
var shimBinder = Assert.IsType<ExtensibleModelBinderAdapter>(oldBinders.DefaultBinder);
Assert.Same(newBinderProviders, shimBinder.Providers);
}
public void BindModel_SuccessfulBind_RunsValidationAndReturnsModel()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
bool validationCalled = false;
ModelBindingContext bindingContext = new ModelBindingContext
{
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(int)),
ModelName = "someName",
ModelState = controllerContext.Controller.ViewData.ModelState,
PropertyFilter = _ => true,
ValueProvider = new SimpleValueProvider
{
{ "someName", "dummyValue" }
}
};
Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
mockIntBinder
.Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
{
Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
Assert.Equal("someName", mbc.ModelName);
Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);
mbc.Model = 42;
mbc.ValidationNode.Validating += delegate { validationCalled = true; };
return true;
});
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
binderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
// Act
object retVal = shimBinder.BindModel(controllerContext, bindingContext);
// Assert
Assert.Equal(42, retVal);
Assert.True(validationCalled);
Assert.True(bindingContext.ModelState.IsValid);
}
private static void TestCacheReset(Action<ModelBinderProviderCollection> mutatingAction)
{
// Arrange
var providers = new List<IModelBinderProvider>()
{
new Mock<IModelBinderProvider>(MockBehavior.Strict).Object,
new Mock<IModelBinderProvider>(MockBehavior.Strict).Object
};
var collection = new ModelBinderProviderCollection(providers);
// Act
mutatingAction(collection);
IModelBinderProvider[] combined = collection.CombinedItems;
// Assert
Assert.Equal(providers, combined);
}
public void ModelBinderProviderCollectionCombinedItemsCaches()
{
// Arrange
var providers = new IModelBinderProvider[]
{
new Mock<IModelBinderProvider>(MockBehavior.Strict).Object,
new Mock<IModelBinderProvider>(MockBehavior.Strict).Object
};
var collection = new ModelBinderProviderCollection(providers);
// Act
var combined1 = collection.CombinedItems;
var combined2 = collection.CombinedItems;
// Assert
Assert.Equal(providers, combined1);
Assert.Same(combined1, combined2);
}
public void GetBinderReturnsNullWhenNoSuccessfulBinderProviders() {
//Arrange
var testType = typeof(string);
IModelBinder nullModelBinder = null;
var provider1 = new Mock<IModelBinderProvider>();
provider1.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);
var provider2 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
provider2.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);
var collection = new ModelBinderProviderCollection(new[] { provider1.Object, provider2.Object });
//Act
IModelBinder returnedBinder = collection.GetBinder(testType);
//Assert
Assert.IsNull(returnedBinder);
}
public void GetBinderReturnsNullIfNoProviderMatches()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object))
};
ModelBinderProviderCollection collection = new ModelBinderProviderCollection(new[]
{
new Mock <ModelBinderProvider>().Object,
});
// Act
IExtensibleModelBinder returned = collection.GetBinder(controllerContext, bindingContext);
// Assert
Assert.Null(returned);
}
public void RegisterBinderForType_Factory()
{
// Arrange
ModelBinderProvider mockProvider = new Mock <ModelBinderProvider>().Object;
IExtensibleModelBinder mockBinder = new Mock <IExtensibleModelBinder>().Object;
ModelBinderProviderCollection collection = new ModelBinderProviderCollection
{
mockProvider
};
// Act
collection.RegisterBinderForType(typeof(int), () => mockBinder);
// Assert
var simpleProvider = Assert.IsType <SimpleModelBinderProvider>(collection[0]);
Assert.Equal(typeof(int), simpleProvider.ModelType);
Assert.Equal(mockProvider, collection[1]);
}
public void GetRequiredBinderThrowsIfNoProviderMatches()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext()
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int))
};
ModelBinderProviderCollection collection = new ModelBinderProviderCollection(new ModelBinderProvider[] {
new Mock <ModelBinderProvider>().Object,
});
// Act & assert
ExceptionHelper.ExpectInvalidOperationException(
delegate {
collection.GetRequiredBinder(controllerContext, bindingContext);
},
@"A binder for type System.Int32 could not be located.");
}
public void RegisterBinderForType_Instance_InsertsNewProviderBehindFrontOfListProviders()
{
// Arrange
ModelBinderProvider frontOfListProvider = new ProviderAtFront();
IExtensibleModelBinder mockBinder = new Mock <IExtensibleModelBinder>().Object;
ModelBinderProviderCollection collection = new ModelBinderProviderCollection()
{
frontOfListProvider
};
// Act
collection.RegisterBinderForType(typeof(int), mockBinder);
// Assert
CollectionAssert.AreEqual(
new Type[] { typeof(ProviderAtFront), typeof(SimpleModelBinderProvider) },
collection.Select(o => o.GetType()).ToArray(),
"New provider should be inserted after any marked 'front of list'.");
}
public void RegisterBinderForGenericType_Type()
{
// Arrange
ModelBinderProvider mockProvider = new Mock <ModelBinderProvider>().Object;
IExtensibleModelBinder mockBinder = new Mock <IExtensibleModelBinder>().Object;
ModelBinderProviderCollection collection = new ModelBinderProviderCollection
{
mockProvider
};
// Act
collection.RegisterBinderForGenericType(typeof(List <>), typeof(CollectionModelBinder <>));
// Assert
var genericProvider = Assert.IsType <GenericModelBinderProvider>(collection[0]);
Assert.Equal(typeof(List <>), genericProvider.ModelType);
Assert.Equal(mockProvider, collection[1]);
}
public void BindModel_PropertyFilterIsSet_Throws() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
ModelBindingContext bindingContext = new ModelBindingContext() {
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(SimpleModel)),
PropertyFilter = (new BindAttribute() { Include = "FirstName " }).IsPropertyAllowed
};
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
// Act & assert
ExceptionHelper.ExpectInvalidOperationException(
delegate {
shimBinder.BindModel(controllerContext, bindingContext);
},
@"The new model binding system cannot be used when a property whitelist or blacklist has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.");
}
public void BindModel_PropertyFilterIsSet_Throws()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
ModelBindingContext bindingContext = new ModelBindingContext
{
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(SimpleModel)),
PropertyFilter = (new BindAttribute { Include = "FirstName " }).IsPropertyAllowed
};
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
// Act & assert
Assert.Throws<InvalidOperationException>(
delegate { shimBinder.BindModel(controllerContext, bindingContext); },
@"The new model binding system cannot be used when a property whitelist or blacklist has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.");
}
public void ModelBinderProviderCollectionCombinedItemsDelegatesToResolver()
{
// Arrange
var firstProvider = new Mock<IModelBinderProvider>();
var secondProvider = new Mock<IModelBinderProvider>();
var thirdProvider = new Mock<IModelBinderProvider>();
var dependencyProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object };
var collectionProviders = new IModelBinderProvider[] { thirdProvider.Object };
var expectedProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };
var resolver = new Mock<IDependencyResolver>();
resolver.Setup(r => r.GetServices(typeof(IModelBinderProvider))).Returns(dependencyProviders);
var providers = new ModelBinderProviderCollection(collectionProviders, resolver.Object);
// Act
IModelBinderProvider[] combined = providers.CombinedItems;
// Assert
Assert.Equal(expectedProviders, combined);
}
public void RegisterBinderForGenericType_Instance()
{
// Arrange
ModelBinderProvider mockProvider = new Mock <ModelBinderProvider>().Object;
IExtensibleModelBinder mockBinder = new Mock <IExtensibleModelBinder>().Object;
ModelBinderProviderCollection collection = new ModelBinderProviderCollection()
{
mockProvider
};
// Act
collection.RegisterBinderForGenericType(typeof(List <>), mockBinder);
// Assert
GenericModelBinderProvider genericProvider = collection[0] as GenericModelBinderProvider;
Assert.IsNotNull(genericProvider, "Generic provider should've been inserted at the front of the list.");
Assert.AreEqual(typeof(List <>), genericProvider.ModelType);
Assert.AreEqual(mockProvider, collection[1]);
}
public void RegisterBinderForType_Instance()
{
// Arrange
ModelBinderProvider mockProvider = new Mock <ModelBinderProvider>().Object;
IExtensibleModelBinder mockBinder = new Mock <IExtensibleModelBinder>().Object;
ModelBinderProviderCollection collection = new ModelBinderProviderCollection()
{
mockProvider
};
// Act
collection.RegisterBinderForType(typeof(int), mockBinder);
// Assert
SimpleModelBinderProvider simpleProvider = collection[0] as SimpleModelBinderProvider;
Assert.IsNotNull(simpleProvider, "Simple provider should've been inserted at the front of the list.");
Assert.AreEqual(typeof(int), simpleProvider.ModelType);
Assert.AreEqual(mockProvider, collection[1]);
}
public void GetBinderConsultsProviders() {
//Arrange
Type modelType = typeof(string);
IModelBinder expectedBinderFromProvider = new Mock<IModelBinder>().Object;
Mock<IModelBinderProvider> locatedProvider = new Mock<IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType))
.Returns(expectedBinderFromProvider);
Mock<IModelBinderProvider> secondProvider = new Mock<IModelBinderProvider>();
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object });
ModelBinderDictionary binders = new ModelBinderDictionary(providers);
//Act
IModelBinder returnedBinder = binders.GetBinder(modelType);
//Assert
Assert.AreSame(expectedBinderFromProvider, returnedBinder);
}
public void GetBinderThrowsIfGenericProviderHasNoParameterlessConstructor()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
null,
typeof(ModelWithProviderAttribute_ProviderHasNoParameterlessConstructor <int>)
),
};
// Act & Assert, confirming type name and full stack are available in Exception
MissingMethodException exception = Assert.Throws <MissingMethodException>(
() => collection.GetBinder(controllerContext, bindingContext),
"No parameterless constructor defined for this object. Object type 'Microsoft.Web.Mvc.ModelBinding.Test.ModelBinderProviderCollectionTest+NoParameterlessCtorBinder`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]'."
);
Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
}
public void GetBinderDelegatesToResolver()
{
// Arrange
Type modelType = typeof(string);
IModelBinder expectedBinder = new Mock <IModelBinder>().Object;
Mock <IModelBinderProvider> locatedProvider = new Mock <IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType)).Returns(expectedBinder);
Mock <IModelBinderProvider> secondProvider = new Mock <IModelBinderProvider>();
Mock <IModelBinderProvider> thirdProvider = new Mock <IModelBinderProvider>();
IModelBinderProvider[] dependencyProviders = new IModelBinderProvider[]
{
locatedProvider.Object,
secondProvider.Object
};
IModelBinderProvider[] collectionProviders = new IModelBinderProvider[]
{
thirdProvider.Object
};
Mock <IDependencyResolver> resolver = new Mock <IDependencyResolver>();
resolver
.Setup(r => r.GetServices(typeof(IModelBinderProvider)))
.Returns(dependencyProviders);
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(
collectionProviders,
resolver.Object
);
// Act
IModelBinder returnedBinder = providers.GetBinder(modelType);
// Assert
Assert.Same(expectedBinder, returnedBinder);
}
public void GetBinderThrowsIfModelTypeHasBindAttribute()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
null,
typeof(ModelWithBindAttribute)
)
};
ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate
{
collection.GetBinder(controllerContext, bindingContext);
},
@"The model of type 'Microsoft.Web.Mvc.ModelBinding.Test.ModelBinderProviderCollectionTest+ModelWithBindAttribute' has a [Bind] attribute. The new model binding system cannot be used with models that have type-level [Bind] attributes. Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead."
);
}
public void GetBinderConsultsProviders()
{
//Arrange
Type modelType = typeof(string);
IModelBinder expectedBinderFromProvider = new Mock <IModelBinder>().Object;
Mock <IModelBinderProvider> locatedProvider = new Mock <IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType))
.Returns(expectedBinderFromProvider);
Mock <IModelBinderProvider> secondProvider = new Mock <IModelBinderProvider>();
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object });
ModelBinderDictionary binders = new ModelBinderDictionary(providers);
//Act
IModelBinder returnedBinder = binders.GetBinder(modelType);
//Assert
Assert.AreSame(expectedBinderFromProvider, returnedBinder);
}
public void GetBinderReturnsNullWhenNoSuccessfulBinderProviders()
{
// Arrange
var testType = typeof(string);
IModelBinder nullModelBinder = null;
var provider1 = new Mock <IModelBinderProvider>();
provider1.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);
var provider2 = new Mock <IModelBinderProvider>(MockBehavior.Strict);
provider2.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);
var collection = new ModelBinderProviderCollection(new[] { provider1.Object, provider2.Object });
// Act
IModelBinder returnedBinder = collection.GetBinder(testType);
// Assert
Assert.Null(returnedBinder);
}
public void ModelBinderProviderCollectionCombinedItemsDelegatesToResolver()
{
// Arrange
var firstProvider = new Mock <IModelBinderProvider>();
var secondProvider = new Mock <IModelBinderProvider>();
var thirdProvider = new Mock <IModelBinderProvider>();
var dependencyProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object };
var collectionProviders = new IModelBinderProvider[] { thirdProvider.Object };
var expectedProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };
var resolver = new Mock <IDependencyResolver>();
resolver.Setup(r => r.GetServices(typeof(IModelBinderProvider))).Returns(dependencyProviders);
var providers = new ModelBinderProviderCollection(collectionProviders, resolver.Object);
// Act
IModelBinderProvider[] combined = providers.CombinedItems;
// Assert
Assert.Equal(expectedProviders, combined);
}
public void GetBinder_FromAttribute_BadAttribute_Throws()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
null,
typeof(ModelWithProviderAttribute_BadAttribute)
)
};
ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
// Act & assert
Assert.Throws <InvalidOperationException>(
delegate
{
providers.GetBinder(controllerContext, bindingContext);
},
@"The type 'System.Object' does not subclass Microsoft.Web.Mvc.ModelBinding.ModelBinderProvider or implement the interface Microsoft.Web.Mvc.ModelBinding.IExtensibleModelBinder."
);
}
public void GetBinderReturnsFirstBinderFromProviders()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
null,
typeof(object)
)
};
IExtensibleModelBinder expectedBinder = new Mock <IExtensibleModelBinder>().Object;
Mock <ModelBinderProvider> mockProvider = new Mock <ModelBinderProvider>();
mockProvider
.Setup(p => p.GetBinder(controllerContext, bindingContext))
.Returns(expectedBinder);
ModelBinderProviderCollection collection = new ModelBinderProviderCollection(
new[]
{
new Mock <ModelBinderProvider>().Object,
mockProvider.Object,
new Mock <ModelBinderProvider>().Object
}
);
// Act
IExtensibleModelBinder returned = collection.GetBinder(
controllerContext,
bindingContext
);
// Assert
Assert.Equal(expectedBinder, returned);
}
public void GetBinderDelegatesToResolver()
{
// Arrange
Type modelType = typeof(string);
IModelBinder expectedBinder = new Mock <IModelBinder>().Object;
Mock <IModelBinderProvider> locatedProvider = new Mock <IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType))
.Returns(expectedBinder);
Mock <IModelBinderProvider> secondProvider = new Mock <IModelBinderProvider>();
Resolver <IEnumerable <IModelBinderProvider> > resolver = new Resolver <IEnumerable <IModelBinderProvider> > {
Current = new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object }
};
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(resolver);
// Act
IModelBinder returnedBinder = providers.GetBinder(modelType);
// Assert
Assert.Same(expectedBinder, returnedBinder);
}
public void GetBinder_FromAttribute_Binder_ValueNotPresent_ReturnsNull()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext()
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder)),
ModelName = "foo",
ValueProvider = new SimpleValueProvider()
{
{ "bar", "barValue" }
}
};
ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder), new Mock <IExtensibleModelBinder>().Object, true /* suppressPrefix */);
// Act
IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);
// Assert
Assert.IsNull(binder, "Binder should've come from attribute rather than collection, even if the attribute's provider returns null.");
}
public void GetBinder_FromAttribute_Binder_ValuePresent_ReturnsBinder()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder)),
ModelName = "foo",
ValueProvider = new SimpleValueProvider
{
{ "foo", "fooValue" }
}
};
ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder), new Mock <IExtensibleModelBinder>().Object, true /* suppressPrefix */);
// Act
IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);
// Assert
Assert.IsType <CustomBinder>(binder);
}
public void GetBinder_FromAttribute_Binder_SuppressPrefixCheck_ReturnsBinder()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext()
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder_SuppressPrefix)),
ModelName = "foo",
ValueProvider = new SimpleValueProvider()
{
{ "bar", "barValue" }
}
};
ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder_SuppressPrefix), new Mock <IExtensibleModelBinder>().Object, true /* suppressPrefix */);
// Act
IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);
// Assert
Assert.AreEqual(typeof(CustomBinder), binder.GetType(), "Binder should've come from attribute rather than collection.");
}
public void BindModel_SuccessfulBind_ComplexTypeFallback_RunsValidationAndReturnsModel() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
bool validationCalled = false;
List<int> expectedModel = new List<int>() { 1, 2, 3, 4, 5 };
ModelBindingContext bindingContext = new ModelBindingContext() {
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
ModelName = "someName",
ModelState = controllerContext.Controller.ViewData.ModelState,
PropertyFilter = _ => true,
ValueProvider = new SimpleValueProvider() {
{ "someOtherName", "dummyValue" }
}
};
Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
mockIntBinder
.Expect(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc) {
Assert.AreSame(bindingContext.ModelMetadata, mbc.ModelMetadata, "ModelMetadata wasn't correct.");
Assert.AreEqual("", mbc.ModelName, "ModelName wasn't correct.");
Assert.AreSame(bindingContext.ValueProvider, mbc.ValueProvider, "ValueProvider wasn't correct.");
mbc.Model = expectedModel;
mbc.ValidationNode.Validating += delegate { validationCalled = true; };
return true;
});
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
binderProviders.RegisterBinderForType(typeof(List<int>), mockIntBinder.Object, false /* suppressPrefixCheck */);
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
// Act
object retVal = shimBinder.BindModel(controllerContext, bindingContext);
// Assert
Assert.AreEqual(expectedModel, retVal);
Assert.IsTrue(validationCalled);
Assert.IsTrue(bindingContext.ModelState.IsValid, "No errors should have been added to ModelState.");
}
public void BindModel_UnsuccessfulBind_SimpleTypeNoFallback_ReturnsNull() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
Mock<ModelBinderProvider> mockBinderProvider = new Mock<ModelBinderProvider>();
mockBinderProvider.Expect(o => o.GetBinder(controllerContext, It.IsAny<ExtensibleModelBindingContext>())).Returns((IExtensibleModelBinder)null).AtMostOnce().Verifiable();
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection() {
mockBinderProvider.Object
};
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
ModelBindingContext bindingContext = new ModelBindingContext() {
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(int)),
ModelState = controllerContext.Controller.ViewData.ModelState
};
// Act
object retVal = shimBinder.BindModel(controllerContext, bindingContext);
// Assert
Assert.IsNull(retVal);
Assert.IsTrue(bindingContext.ModelState.IsValid, "No errors should have been added to ModelState.");
mockBinderProvider.Verify();
}
public static void RegisterBinderProviders(ModelBinderProviderCollection binderProviders)
{
binderProviders.Add(new EntityBinder());
}
public void BindModel() {
// Arrange
ControllerContext controllerContext = new ControllerContext();
MyModel model = new MyModel();
ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(MyModel));
ComplexModelDto dto = new ComplexModelDto(modelMetadata, modelMetadata.Properties);
Mock<IExtensibleModelBinder> mockStringBinder = new Mock<IExtensibleModelBinder>();
mockStringBinder
.Expect(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc) {
Assert.AreEqual(typeof(string), mbc.ModelType);
Assert.AreEqual("theModel.StringProperty", mbc.ModelName);
mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.StringProperty");
mbc.Model = "someStringValue";
return true;
});
Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
mockIntBinder
.Expect(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc) {
Assert.AreEqual(typeof(int), mbc.ModelType);
Assert.AreEqual("theModel.IntProperty", mbc.ModelName);
mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.IntProperty");
mbc.Model = 42;
return true;
});
Mock<IExtensibleModelBinder> mockDateTimeBinder = new Mock<IExtensibleModelBinder>();
mockDateTimeBinder
.Expect(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc) {
Assert.AreEqual(typeof(DateTime), mbc.ModelType);
Assert.AreEqual("theModel.DateTimeProperty", mbc.ModelName);
return false;
});
ModelBinderProviderCollection binders = new ModelBinderProviderCollection();
binders.RegisterBinderForType(typeof(string), mockStringBinder.Object, true /* suppressPrefixCheck */);
binders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);
binders.RegisterBinderForType(typeof(DateTime), mockDateTimeBinder.Object, true /* suppressPrefixCheck */);
ExtensibleModelBindingContext parentBindingContext = new ExtensibleModelBindingContext() {
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => dto, typeof(ComplexModelDto)),
ModelName = "theModel",
ModelBinderProviders = binders
};
ComplexModelDtoModelBinder binder = new ComplexModelDtoModelBinder();
// Act
bool retVal = binder.BindModel(controllerContext, parentBindingContext);
// Assert
Assert.IsTrue(retVal);
Assert.AreEqual(dto, parentBindingContext.Model, "The return model should have been the original DTO.");
ComplexModelDtoResult stringDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(string)).First()];
Assert.AreEqual("someStringValue", stringDtoResult.Model);
Assert.AreEqual("theModel.StringProperty", stringDtoResult.ValidationNode.ModelStateKey);
ComplexModelDtoResult intDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(int)).First()];
Assert.AreEqual(42, intDtoResult.Model);
Assert.AreEqual("theModel.IntProperty", intDtoResult.ValidationNode.ModelStateKey);
ComplexModelDtoResult dateTimeDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(DateTime)).First()];
Assert.IsNull(dateTimeDtoResult);
}
public void GetBinderDelegatesToResolver()
{
// Arrange
Type modelType = typeof(string);
IModelBinder expectedBinder = new Mock<IModelBinder>().Object;
Mock<IModelBinderProvider> locatedProvider = new Mock<IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType))
.Returns(expectedBinder);
Mock<IModelBinderProvider> secondProvider = new Mock<IModelBinderProvider>();
Resolver<IEnumerable<IModelBinderProvider>> resolver = new Resolver<IEnumerable<IModelBinderProvider>> { Current = new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object } };
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(resolver);
// Act
IModelBinder returnedBinder = providers.GetBinder(modelType);
// Assert
Assert.Same(expectedBinder, returnedBinder);
}
public void GetBinderDelegatesToResolver()
{
// Arrange
Type modelType = typeof(string);
IModelBinder expectedBinder = new Mock<IModelBinder>().Object;
Mock<IModelBinderProvider> locatedProvider = new Mock<IModelBinderProvider>();
locatedProvider.Setup(p => p.GetBinder(modelType))
.Returns(expectedBinder);
Mock<IModelBinderProvider> secondProvider = new Mock<IModelBinderProvider>();
Mock<IModelBinderProvider> thirdProvider = new Mock<IModelBinderProvider>();
IModelBinderProvider[] dependencyProviders = new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object };
IModelBinderProvider[] collectionProviders = new IModelBinderProvider[] { thirdProvider.Object };
Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
resolver.Setup(r => r.GetServices(typeof(IModelBinderProvider))).Returns(dependencyProviders);
ModelBinderProviderCollection providers = new ModelBinderProviderCollection(collectionProviders, resolver.Object);
// Act
IModelBinder returnedBinder = providers.GetBinder(modelType);
// Assert
Assert.Same(expectedBinder, returnedBinder);
}
public ExtensibleModelBinderAdapter(ModelBinderProviderCollection providers)
{
Providers = providers ?? ModelBinderProviders.Providers;
}
public void BindModel_UnsuccessfulBind_BinderFails_ReturnsNull() {
// Arrange
ControllerContext controllerContext = GetControllerContext();
Mock<IExtensibleModelBinder> mockListBinder = new Mock<IExtensibleModelBinder>();
mockListBinder.Expect(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>())).Returns(false).Verifiable();
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
binderProviders.RegisterBinderForType(typeof(List<int>), mockListBinder.Object, true /* suppressPrefixCheck */);
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);
ModelBindingContext bindingContext = new ModelBindingContext() {
FallbackToEmptyPrefix = false,
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
ModelState = controllerContext.Controller.ViewData.ModelState
};
// Act
object retVal = shimBinder.BindModel(controllerContext, bindingContext);
// Assert
Assert.IsNull(retVal);
Assert.IsTrue(bindingContext.ModelState.IsValid, "No errors should have been added to ModelState.");
mockListBinder.Verify();
}
public void BindModel_SuccessfulBind_RunsValidationAndReturnsModel()
{
// Arrange
ControllerContext controllerContext = GetControllerContext();
bool validationCalled = false;
ModelBindingContext bindingContext = new ModelBindingContext
{
FallbackToEmptyPrefix = true,
ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(
null,
typeof(int)
),
ModelName = "someName",
ModelState = controllerContext.Controller.ViewData.ModelState,
PropertyFilter = _ => true,
ValueProvider = new SimpleValueProvider {
{ "someName", "dummyValue" }
}
};
Mock <IExtensibleModelBinder> mockIntBinder = new Mock <IExtensibleModelBinder>();
mockIntBinder
.Setup(
o => o.BindModel(controllerContext, It.IsAny <ExtensibleModelBindingContext>())
)
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
{
Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
Assert.Equal("someName", mbc.ModelName);
Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);
mbc.Model = 42;
mbc.ValidationNode.Validating += delegate
{
validationCalled = true;
};
return(true);
}
);
ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
binderProviders.RegisterBinderForType(
typeof(int),
mockIntBinder.Object,
false /* suppressPrefixCheck */
);
ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(
binderProviders
);
// Act
object retVal = shimBinder.BindModel(controllerContext, bindingContext);
// Assert
Assert.Equal(42, retVal);
Assert.True(validationCalled);
Assert.True(bindingContext.ModelState.IsValid);
}
internal static void Initialize(ModelBinderDictionary binders, ModelBinderProviderCollection providers)
{
binders.Clear();
binders.DefaultBinder = new ExtensibleModelBinderAdapter(providers);
}
public void BindModel()
{
// Arrange
ControllerContext controllerContext = new ControllerContext();
MyModel model = new MyModel();
ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(MyModel));
ComplexModelDto dto = new ComplexModelDto(modelMetadata, modelMetadata.Properties);
Mock <IExtensibleModelBinder> mockStringBinder = new Mock <IExtensibleModelBinder>();
mockStringBinder
.Setup(b => b.BindModel(controllerContext, It.IsAny <ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
{
Assert.Equal(typeof(string), mbc.ModelType);
Assert.Equal("theModel.StringProperty", mbc.ModelName);
mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.StringProperty");
mbc.Model = "someStringValue";
return(true);
});
Mock <IExtensibleModelBinder> mockIntBinder = new Mock <IExtensibleModelBinder>();
mockIntBinder
.Setup(b => b.BindModel(controllerContext, It.IsAny <ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
{
Assert.Equal(typeof(int), mbc.ModelType);
Assert.Equal("theModel.IntProperty", mbc.ModelName);
mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.IntProperty");
mbc.Model = 42;
return(true);
});
Mock <IExtensibleModelBinder> mockDateTimeBinder = new Mock <IExtensibleModelBinder>();
mockDateTimeBinder
.Setup(b => b.BindModel(controllerContext, It.IsAny <ExtensibleModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
{
Assert.Equal(typeof(DateTime), mbc.ModelType);
Assert.Equal("theModel.DateTimeProperty", mbc.ModelName);
return(false);
});
ModelBinderProviderCollection binders = new ModelBinderProviderCollection();
binders.RegisterBinderForType(typeof(string), mockStringBinder.Object, true /* suppressPrefixCheck */);
binders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);
binders.RegisterBinderForType(typeof(DateTime), mockDateTimeBinder.Object, true /* suppressPrefixCheck */);
ExtensibleModelBindingContext parentBindingContext = new ExtensibleModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => dto, typeof(ComplexModelDto)),
ModelName = "theModel",
ModelBinderProviders = binders
};
ComplexModelDtoModelBinder binder = new ComplexModelDtoModelBinder();
// Act
bool retVal = binder.BindModel(controllerContext, parentBindingContext);
// Assert
Assert.True(retVal);
Assert.Equal(dto, parentBindingContext.Model);
ComplexModelDtoResult stringDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(string)).First()];
Assert.Equal("someStringValue", stringDtoResult.Model);
Assert.Equal("theModel.StringProperty", stringDtoResult.ValidationNode.ModelStateKey);
ComplexModelDtoResult intDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(int)).First()];
Assert.Equal(42, intDtoResult.Model);
Assert.Equal("theModel.IntProperty", intDtoResult.ValidationNode.ModelStateKey);
ComplexModelDtoResult dateTimeDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(DateTime)).First()];
Assert.Null(dateTimeDtoResult);
}
public static void Configure(ModelBinderProviderCollection binders)
{
binders.Add(new QuestionModelBinderProvider());
binders.Add(new CustomCancellationTokenModelBinder());
}
internal static void RegisterModelBinders(ModelBinderProviderCollection modelBinderProviderCollection)
{
modelBinderProviderCollection.Add(new EntityModelBinderProvider());
}
