public override IEnumerable <ModelValidationResult> Validate(object container)
{
bool propertiesValid = true;
foreach (ModelMetadata propertyMetadata in Metadata.Properties)
{
foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(ControllerContext))
{
foreach (ModelValidationResult propertyResult in propertyValidator.Validate(Metadata.Model))
{
propertiesValid = false;
yield return(new ModelValidationResult
{
MemberName = DefaultModelBinder.CreateSubPropertyName(propertyMetadata.PropertyName, propertyResult.MemberName),
Message = propertyResult.Message
});
}
}
}
if (propertiesValid)
{
foreach (ModelValidator typeValidator in Metadata.GetValidators(ControllerContext))
{
foreach (ModelValidationResult typeResult in typeValidator.Validate(container))
{
yield return(typeResult);
}
}
}
}
public void SetUp()
{
binder = new DefaultModelBinder();
controllerContext = new ControllerContext
{
HttpContext = MockRepository.GenerateStub<HttpContextBase>()
};
request = MockRepository.GenerateStub<HttpRequestBase>();
controllerContext.HttpContext.Stub(x => x.Request).Return(request);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
if (bindingContext.ModelType.IsInterface || bindingContext.ModelType.IsAbstract)
{
return Easy.Reflection.ClassAction.GetModel(ServiceLocator.Current.GetInstance(bindingContext.ModelType).GetType(), controllerContext.RequestContext.HttpContext.Request.Form);
}
else
{
DefaultModelBinder binder = new DefaultModelBinder();
return binder.BindModel(controllerContext, bindingContext);
}
}
public void all_parameters_are_bound()
{
var form = new FormCollection()
{
{ "Name", "test_name" }
};
var context = new ModelBindingContext() { ValueProvider = form.ToValueProvider(), ModelType = typeof(CodeCamp) };
var mb = new DefaultModelBinder();
var codeCamp = (CodeCamp) mb.BindModel(null, context);
Assert.That(codeCamp.Name, Is.EqualTo("test_name"));
}
public void ProceedAndWrapResultWithRuntimePolicyOnAndDefaultModelBinder(AlternateType<IModelBinder> alternateModelBinder, IAlternateMethodContext context, Type arg1, DefaultModelBinder returnValue, IModelBinder newModelBinder)
{
context.Setup(c => c.Arguments).Returns(new object[] { arg1 });
context.Setup(c => c.ReturnValue).Returns(returnValue);
alternateModelBinder.Setup(amb => amb.TryCreate(It.IsAny<IModelBinder>(), out newModelBinder, null, null)).Returns(true);
var sut = new ModelBinderProvider.GetBinder(alternateModelBinder);
sut.NewImplementation(context);
context.TimerStrategy().Verify(t => t.Time(It.IsAny<Action>()));
context.Verify(mb => mb.ReturnValue);
context.Logger.Verify(l => l.Warn(It.IsAny<string>(), context.ReturnValue.GetType()), Times.Never());
context.VerifySet(c => c.ReturnValue = newModelBinder);
alternateModelBinder.Verify(amb => amb.TryCreate(It.IsAny<IModelBinder>(), out newModelBinder, null, null));
}
public string Get(ControllerContext controllerContext)
{
var defaultModelBinder = new DefaultModelBinder();
var modelType = typeof(GiftCardInfo);
var giftCardInfo = new GiftCardInfo();
var metadataForType = ModelMetadataProviders.Current.GetMetadataForType(() => giftCardInfo, modelType);
metadataForType.Model = giftCardInfo;
var modelBindingContext = new ModelBindingContext
{
ModelMetadata = metadataForType,
ValueProvider = new FormValueProvider(controllerContext)
};
var model = defaultModelBinder.BindModel(controllerContext, modelBindingContext) as GiftCardInfo;
return model == null ? null : JsonConvert.SerializeObject(model);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
DefaultModelBinder binder = new DefaultModelBinder(); // use the default model binder to do the dirty work
ModelBindingContext listBindingContext = new ModelBindingContext
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => bindingContext.Model, bindingContext.ModelType),
ModelName = bindingContext.ModelName,
ModelState = bindingContext.ModelState,
ValueProvider = bindingContext.ValueProvider,
PropertyFilter = bindingContext.PropertyFilter
};
ImageList list = binder.BindModel(controllerContext, listBindingContext) as ImageList;
return list;
}
private AccountController CreateAccountController(object ViewModel)
{
var accountController = new AccountController(MockingHelper.ApplicationManager);
accountController.ControllerContext = MockingHelper.ControllerContext;
if (ViewModel != null)
{
var modelBinder = new ModelBindingContext()
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => ViewModel, ViewModel.GetType()),
ValueProvider = new NameValueCollectionValueProvider(new NameValueCollection(), CultureInfo.InvariantCulture)
};
var binder = new DefaultModelBinder().BindModel(accountController.ControllerContext, modelBinder);
accountController.ModelState.Clear();
accountController.ModelState.Merge(modelBinder.ModelState);
}
return accountController;
}
public static object ConvertToObject(this FormDataCollection formDataCollection, Type type)
{
try
{
DefaultModelBinder binder = new DefaultModelBinder();
ModelBindingContext modelBindingContext = new ModelBindingContext()
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, type),
ValueProvider = new FormValueProvider(formDataCollection.ReadAsNameValueCollection())
};
return binder.BindModel(new ControllerContext(), modelBindingContext);
}
catch (Exception)
{
return null;
}
}
public static ModelStateDictionary ReturnModelState(this TestModel model)
{
var testController = new TestController();
var modelBinder = new ModelBindingContext()
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(
() => model, model.GetType()),
ValueProvider = new NameValueCollectionValueProvider(
new NameValueCollection(), CultureInfo.InvariantCulture)
};
var binder = new DefaultModelBinder().BindModel(
new ControllerContext(), modelBinder);
testController.ModelState.Clear();
testController.ModelState.Merge(modelBinder.ModelState);
var viewResult = (ViewResult) testController.ValidDateTestModel(model);
return viewResult.ViewData.ModelState;
}
public void BindComplexModelCanBindArrays() {
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int[]),
PropertyFilter = _ => false,
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "foo[0]", null }, { "foo[1]", null }, { "foo[2]", null } }
};
Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
mockInnerBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(int), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(bindingContext.PropertyFilter, bc.PropertyFilter, "PropertyFilter was not forwarded correctly.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockInnerBinder.Object }
}
};
// Act
object newModel = binder.BindComplexModel(controllerContext, bindingContext);
// Assert
Assert.IsInstanceOfType(newModel, typeof(int[]));
int[] newIntArray = (int[])newModel;
Assert.AreEqual(3, newIntArray.Length, "Model is not of correct length.");
Assert.AreEqual(0, newIntArray[0]);
Assert.AreEqual(1, newIntArray[1]);
Assert.AreEqual(2, newIntArray[2]);
}
public void BindSimpleModelCanReturnArrayTypes() {
// Arrange
ValueProviderResult result = new ValueProviderResult(42, null, null);
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int[])
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedValue = binder.BindSimpleModel(null, bindingContext, result);
// Assert
Assert.IsInstanceOfType(returnedValue, typeof(int[]), "Returned value was of incorrect type.");
int[] returnedValueAsIntArray = (int[])returnedValue;
Assert.AreEqual(1, returnedValueAsIntArray.Length);
Assert.AreEqual(42, returnedValueAsIntArray[0]);
}
public void BindModelReturnsNullIfSimpleTypeNotFound() {
// DevDiv 216165: ModelBinders should not try and instantiate simple types
// Arrange
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "prefix",
ModelType = typeof(string),
ValueProvider = new ValueProviderDictionary(null) {
{ "prefix.foo", new ValueProviderResult("foo", "foo", null) },
{ "prefix.bar", new ValueProviderResult("bar", "bar", null) }
}
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object updatedModel = binder.BindModel(null, bindingContext);
// Assert
Assert.IsNull(updatedModel);
}
public void BindModelWithPrefixReturnsNullIfFallbackNotSpecifiedAndValueProviderContainsNoEntries() {
// Arrange
ModelWithoutBindAttribute model = new ModelWithoutBindAttribute() {
Foo = "FooPreValue",
Bar = "BarPreValue",
Baz = "BazPreValue",
};
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelName = "prefix",
ModelType = typeof(ModelWithoutBindAttribute),
ValueProvider = new ValueProviderDictionary(null) {
{ "foo", new ValueProviderResult("FooPostValue", "FooPostValue", null) },
{ "bar", new ValueProviderResult("BarPostValue", "BarPostValue", null) }
}
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object updatedModel = binder.BindModel(null, bindingContext);
// Assert
Assert.IsNull(updatedModel);
}
public void BindComplexModelCanBindDictionaries() {
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelType = typeof(IDictionary<int, string>),
ModelName = "foo",
PropertyFilter = _ => false,
ValueProvider = new Dictionary<string, ValueProviderResult>() {
{ "foo[0].key", null }, { "foo[0].value", null },
{ "foo[1].key", null }, { "foo[1].value", null },
{ "foo[2].key", null }, { "foo[2].value", null }
}
};
Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
mockIntBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(int), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(new ModelBindingContext().PropertyFilter, bc.PropertyFilter, "PropertyFilter should not have been set.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10;
});
Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
mockStringBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(string), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(bindingContext.PropertyFilter, bc.PropertyFilter, "PropertyFilter was not forwarded correctly.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value";
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockIntBinder.Object },
{ typeof(string), mockStringBinder.Object }
}
};
// Act
object newModel = binder.BindComplexModel(controllerContext, bindingContext);
// Assert
Assert.IsInstanceOfType(newModel, typeof(IDictionary<int, string>));
IDictionary<int, string> modelAsDictionary = (IDictionary<int, string>)newModel;
Assert.AreEqual(3, modelAsDictionary.Count, "Model is not of correct length.");
Assert.AreEqual("10Value", modelAsDictionary[10]);
Assert.AreEqual("11Value", modelAsDictionary[11]);
Assert.AreEqual("12Value", modelAsDictionary[12]);
}
public void BindSimpleModelChecksValueProviderResultRawValueType() {
// Arrange
ValueProviderResult result = new ValueProviderResult(new MemoryStream(), null, null);
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(Stream)
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedValue = binder.BindSimpleModel(null, bindingContext, result);
// Assert
Assert.AreEqual(result, bindingContext.ModelState["foo"].Value, "ModelState should have been set.");
Assert.AreSame(result.RawValue, returnedValue, "Should have returned the RawValue since it was of the correct type.");
}
public void UpdateCollectionCreatesDefaultEntriesForInvalidElements() {
// Arrange
List<int> model = new List<int>() { 4, 5, 6, 7, 8 };
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelName = "foo",
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "foo[0]", null }, { "foo[1]", null }, { "foo[2]", null } }
};
Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
mockInnerBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
int fooIdx = Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
return (fooIdx == 1) ? (object)null : fooIdx;
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockInnerBinder.Object }
}
};
// Act
object updatedModel = binder.UpdateCollection(null, bindingContext, typeof(int));
// Assert
Assert.AreEqual(3, model.Count, "Model is not of correct length.");
Assert.AreEqual(false, bindingContext.ModelState.IsValidField("foo[1]"), "Conversion should have failed.");
Assert.AreEqual("A value is required.", bindingContext.ModelState["foo[1]"].Errors[0].ErrorMessage, "Error message did not propagate correctly.");
Assert.AreEqual(0, model[0]);
Assert.AreEqual(0, model[1]);
Assert.AreEqual(2, model[2]);
}
public void BindModelCanBindObjects() {
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
ModelWithoutBindAttribute model = new ModelWithoutBindAttribute() {
Foo = "FooPreValue",
Bar = "BarPreValue",
Baz = "BazPreValue",
};
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelType = typeof(ModelWithoutBindAttribute),
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "Foo", null }, { "Bar", null } }
};
Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
mockInnerBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "Value provider was not forwarded correctly.");
return bc.ModelName + "PostValue";
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(string), mockInnerBinder.Object }
}
};
// Act
object updatedModel = binder.BindModel(controllerContext, bindingContext);
// Assert
Assert.AreSame(model, updatedModel, "Should have returned same instance of the model.");
Assert.AreEqual("FooPostValue", model.Foo, "Foo property should have been updated.");
Assert.AreEqual("BarPostValue", model.Bar, "Bar property should have been updated.");
Assert.AreEqual("BazPreValue", model.Baz, "Baz property shouldn't have been updated since it wasn't part of the request.");
}
public void BindComplexModelReturnsNullArrayIfNoValuesProvided() {
// Arrange
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int[]),
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "foo", null } }
};
Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
mockInnerBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockInnerBinder.Object }
}
};
// Act
object newModel = binder.BindComplexModel(null, bindingContext);
// Assert
Assert.IsNull(newModel, "Method should have returned null.");
}
public void UpdateDictionarySkipsInvalidKeys() {
// Arrange
Dictionary<int, string> model = new Dictionary<int, string>{
{ 1, "one" },
{ 2, "two" }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelName = "foo",
ValueProvider = new Dictionary<string, ValueProviderResult>() {
{ "foo[0].key", null }, { "foo[0].value", null },
{ "foo[1].key", null }, { "foo[1].value", null },
{ "foo[2].key", null }, { "foo[2].value", null }
}
};
Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
mockIntBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
int fooIdx = Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
return (fooIdx == 1) ? (object)null : fooIdx;
});
Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
mockStringBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value";
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockIntBinder.Object },
{ typeof(string), mockStringBinder.Object }
}
};
// Act
object updatedModel = binder.UpdateDictionary(null, bindingContext, typeof(int), typeof(string));
// Assert
Assert.AreEqual(2, model.Count, "Model is not of correct length.");
Assert.AreEqual(false, bindingContext.ModelState.IsValidField("foo[1].key"), "Conversion should have failed.");
Assert.AreEqual("A value is required.", bindingContext.ModelState["foo[1].key"].Errors[0].ErrorMessage, "Error message did not propagate correctly.");
Assert.AreEqual("10Value", model[0]);
Assert.AreEqual("12Value", model[2]);
}
public void UpdateDictionaryReturnsNullIfNoValidElementsFound() {
// Arrange
ModelBindingContext bindingContext = new ModelBindingContext() {
ValueProvider = new Dictionary<string, ValueProviderResult>()
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object updatedModel = binder.UpdateDictionary(null, bindingContext, typeof(object), typeof(object));
// Assert
Assert.IsNull(updatedModel, "Method should return null if no values exist as part of the request.");
}
public void UpdateDictionaryReturnsModifiedDictionaryOnSuccess() {
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
Dictionary<int, string> model = new Dictionary<int, string>{
{ 1, "one" },
{ 2, "two" }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelName = "foo",
PropertyFilter = _ => false,
ValueProvider = new Dictionary<string, ValueProviderResult>() {
{ "foo[0].key", null }, { "foo[0].value", null },
{ "foo[1].key", null }, { "foo[1].value", null },
{ "foo[2].key", null }, { "foo[2].value", null }
}
};
Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
mockIntBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(int), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(new ModelBindingContext().PropertyFilter, bc.PropertyFilter, "PropertyFilter should not have been set.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10;
});
Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
mockStringBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(string), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(bindingContext.PropertyFilter, bc.PropertyFilter, "PropertyFilter was not forwarded correctly.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value";
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockIntBinder.Object },
{ typeof(string), mockStringBinder.Object }
}
};
// Act
object updatedModel = binder.UpdateDictionary(controllerContext, bindingContext, typeof(int), typeof(string));
// Assert
Assert.AreSame(model, updatedModel, "Should have updated the provided model object.");
Assert.AreEqual(3, model.Count, "Model is not of correct length.");
Assert.AreEqual("10Value", model[10]);
Assert.AreEqual("11Value", model[11]);
Assert.AreEqual("12Value", model[12]);
}
public void BindSimpleModelCanReturnCollectionTypes() {
// Arrange
ValueProviderResult result = new ValueProviderResult(new string[] { "42", "82" }, null, null);
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(IEnumerable<int>)
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedValue = binder.BindSimpleModel(null, bindingContext, result);
// Assert
Assert.IsInstanceOfType(returnedValue, typeof(IEnumerable<int>), "Returned value was of incorrect type.");
List<int> returnedValueAsList = ((IEnumerable<int>)returnedValue).ToList();
Assert.AreEqual(2, returnedValueAsList.Count);
Assert.AreEqual(42, returnedValueAsList[0]);
Assert.AreEqual(82, returnedValueAsList[1]);
}
public void BindSimpleModelCanReturnStrings() {
// Arrange
ValueProviderResult result = new ValueProviderResult(new object[] { "42" }, null, null);
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(string)
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedValue = binder.BindSimpleModel(null, bindingContext, result);
// Assert
Assert.AreEqual("42", returnedValue);
}
public void BindModelReturnsNullIfKeyNotFound() {
// Arrange
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int),
ValueProvider = new Dictionary<string, ValueProviderResult>()
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedModel = binder.BindModel(null, bindingContext);
// Assert
Assert.IsNull(returnedModel);
}
public void BindSimpleModelPropagatesErrorsOnFailure() {
// Arrange
ValueProviderResult result = new ValueProviderResult("invalid", null, null);
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int)
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object returnedValue = binder.BindSimpleModel(null, bindingContext, result);
// Assert
Assert.IsFalse(bindingContext.ModelState.IsValidField("foo"), "Foo should be an invalid field.");
Assert.IsInstanceOfType(bindingContext.ModelState["foo"].Errors[0].Exception, typeof(InvalidOperationException));
Assert.AreEqual("The parameter conversion from type 'System.String' to type 'System.Int32' failed. See the inner exception for more information.", bindingContext.ModelState["foo"].Errors[0].Exception.Message);
Assert.IsNull(returnedValue, "Should have returned null on failure.");
}
public void BindModelThrowsIfBindingContextIsNull() {
// Arrange
DefaultModelBinder binder = new DefaultModelBinder();
// Act & assert
ExceptionHelper.ExpectArgumentNullException(
delegate {
binder.BindModel(null, null);
}, "bindingContext");
}
protected void Application_Start()
{
_Logger = _Kernel.Get<ILogger>();
_Logger.Info("Application Started");
// Inject account repository into our custom membership & role providers.
_Kernel.Inject(Membership.Provider);
_Kernel.Inject(Roles.Provider);
LocalisationDynamicNodeProvider.RegisterKernel(_Kernel);
ModelFactory.RegisterKernel(_Kernel);
PaymentHandlerFactory.RegisterKernel(_Kernel);
InitialiseAdmin();
//Inject
ControllerBuilder.Current.SetControllerFactory(new NinjectControlerFactory(_Kernel));
//routes
AreaRegistration.RegisterAllAreas();
XmlSiteMapController.RegisterRoutes(RouteTable.Routes);
GlobalFilters.Filters.Add(new RedirectMobileDevicesToMobileAreaAttribute(), 1);
RegisterRoutes(RouteTable.Routes);
//RouteDebug.RouteDebugger.RewriteRoutesForTesting(RouteTable.Routes);
//model binder
var defaultBinder = new DefaultModelBinder();
ModelBinders.Binders.DefaultBinder = defaultBinder;
ModelBinders.Binders.Add(typeof(Localisation), new LocalisationBinder(defaultBinder));
ModelBinders.Binders.Add(typeof(Rental), new RentalBinder(defaultBinder));
ModelBinders.Binders.Add(typeof(Offer), new OfferBinder(defaultBinder));
ModelBinders.Binders.Add(typeof(LocalisationCart), new LocalisationCartBinder(defaultBinder));
//resources
DefaultModelBinder.ResourceClassKey = "Messages";
}
public void BindModelWithPrefixAndFallback() {
// Arrange
ModelWithoutBindAttribute model = new ModelWithoutBindAttribute() {
Foo = "FooPreValue",
Bar = "BarPreValue",
Baz = "BazPreValue",
};
ModelBindingContext bindingContext = new ModelBindingContext() {
FallbackToEmptyPrefix = true,
Model = model,
ModelName = "prefix",
ModelType = typeof(ModelWithoutBindAttribute),
ValueProvider = new ValueProviderDictionary(null) {
{ "foo", new ValueProviderResult("FooPostValue", "FooPostValue", null) },
{ "bar", new ValueProviderResult("BarPostValue", "BarPostValue", null) }
}
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object updatedModel = binder.BindModel(null, bindingContext);
// Assert
Assert.AreSame(model, updatedModel, "Should have returned same instance of the model.");
Assert.AreEqual("FooPostValue", model.Foo, "Foo property should have been updated.");
Assert.AreEqual("BarPostValue", model.Bar, "Bar property should have been updated.");
Assert.AreEqual("BazPreValue", model.Baz, "Baz property shouldn't have been updated since it wasn't part of the request.");
}
public void BindModelCanBindSimpleTypes() {
// Arrange
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ModelType = typeof(int),
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "foo", new ValueProviderResult("42", "42", null) } }
};
DefaultModelBinder binder = new DefaultModelBinder();
// Act
object updatedModel = binder.BindModel(null, bindingContext);
// Assert
Assert.AreEqual(42, updatedModel);
}
public void UpdateCollectionReturnsModifiedCollectionOnSuccess() {
// Arrange
ControllerContext controllerContext = new Mock<ControllerContext>().Object;
List<int> model = new List<int>() { 4, 5, 6, 7, 8 };
ModelBindingContext bindingContext = new ModelBindingContext() {
Model = model,
ModelName = "foo",
PropertyFilter = _ => false,
ValueProvider = new Dictionary<string, ValueProviderResult>() { { "foo[0]", null }, { "foo[1]", null }, { "foo[2]", null } }
};
Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
mockInnerBinder
.Expect(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
.Returns(
delegate(ControllerContext cc, ModelBindingContext bc) {
Assert.AreEqual(controllerContext, cc, "ControllerContext was not forwarded correctly.");
Assert.AreEqual(typeof(int), bc.ModelType, "ModelType was not forwarded correctly.");
Assert.AreEqual(bindingContext.ModelState, bc.ModelState, "ModelState was not forwarded correctly.");
Assert.AreEqual(bindingContext.PropertyFilter, bc.PropertyFilter, "PropertyFilter was not forwarded correctly.");
Assert.AreEqual(bindingContext.ValueProvider, bc.ValueProvider, "ValueProvider was not forwarded correctly.");
return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
});
DefaultModelBinder binder = new DefaultModelBinder() {
Binders = new ModelBinderDictionary() {
{ typeof(int), mockInnerBinder.Object }
}
};
// Act
object updatedModel = binder.UpdateCollection(controllerContext, bindingContext, typeof(int));
// Assert
Assert.AreSame(model, updatedModel, "Should have updated the provided model object.");
Assert.AreEqual(3, model.Count, "Model is not of correct length.");
Assert.AreEqual(0, model[0]);
Assert.AreEqual(1, model[1]);
Assert.AreEqual(2, model[2]);
}