public async Task BindModelAsync_ValueProviderContainPrefix_Succeeds()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "84" },
};
var bindingContext = GetBindingContext(valueProvider);
var metadataProvider = new TestModelMetadataProvider();
bindingContext.ModelMetadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithIntArrayProperty),
nameof(ModelWithIntArrayProperty.ArrayProperty));
var binder = new ArrayModelBinder<int>(new SimpleTypeModelBinder(typeof(int)));
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(bindingContext.Result.IsModelSet);
var array = Assert.IsType<int[]>(bindingContext.Result.Model);
Assert.Equal(new[] { 42, 84 }, array);
}
public async Task BindModel_ComplexCollection_Succeeds(bool isReadOnly)
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName.index", new[] { "foo", "bar", "baz" } },
{ "someName[foo]", "42" },
{ "someName[bar]", "100" },
{ "someName[baz]", "200" }
};
var bindingContext = GetModelBindingContext(valueProvider, isReadOnly);
var modelState = bindingContext.ModelState;
var binder = new CollectionModelBinder<int>(CreateIntBinder());
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(bindingContext.Result.IsModelSet);
var list = Assert.IsAssignableFrom<IList<int>>(bindingContext.Result.Model);
Assert.Equal(new[] { 42, 100, 200 }, list.ToArray());
Assert.True(modelState.IsValid);
}
public async Task BindModel_SubBindingSucceeds()
{
// Arrange
var valueProvider = new SimpleValueProvider();
var bindingContext = GetBindingContext(valueProvider, typeof(KeyValuePair<int, string>));
var binder = new KeyValuePairModelBinder<int, string>(CreateIntBinder(), CreateStringBinder());
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(bindingContext.Result.IsModelSet);
Assert.Equal(new KeyValuePair<int, string>(42, "some-value"), bindingContext.Result.Model);
}
public async Task BindModel_MissingKeyAndMissingValue_DoNotAddModelStateError()
{
// Arrange
var valueProvider = new SimpleValueProvider();
// Create int binder to create the value but not the key.
var bindingContext = GetBindingContext(valueProvider, typeof(KeyValuePair<int, string>));
var binder = new KeyValuePairModelBinder<int, string>(CreateIntBinder(false), CreateStringBinder(false));
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.False(bindingContext.Result.IsModelSet);
Assert.True(bindingContext.ModelState.IsValid);
Assert.Equal(0, bindingContext.ModelState.ErrorCount);
}
public async Task BindModel()
{
// Arrange
var valueProvider = new SimpleValueProvider()
{
{ "foo", "Fys1" }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotNull(binderResult);
var bytes = Assert.IsType<byte[]>(binderResult.Model);
Assert.Equal(new byte[] { 23, 43, 53 }, bytes);
}
public void BinderWithEmptyStringValueReturnsNull() {
// Arrange
SimpleValueProvider valueProvider = new SimpleValueProvider() {
{ "foo", "" }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ValueProvider = valueProvider
};
ByteArrayModelBinder binder = new ByteArrayModelBinder();
// Act
object binderResult = binder.BindModel(null, bindingContext);
// Assert
Assert.IsNull(binderResult);
}
public void BindModelWithNonExistentValueReturnsNull() {
// Arrange
SimpleValueProvider valueProvider = new SimpleValueProvider() {
{ "foo", null }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ValueProvider = valueProvider
};
LinqBinaryModelBinder binder = new LinqBinaryModelBinder();
// Act
object binderResult = binder.BindModel(null, bindingContext);
// Assert
Assert.IsNull(binderResult);
}
public async Task BindModel_MissingKey_ReturnsResult_AndAddsModelValidationError()
{
// Arrange
var valueProvider = new SimpleValueProvider();
// Create string binder to create the value but not the key.
var bindingContext = GetBindingContext(valueProvider, typeof(KeyValuePair<int, string>));
var binder = new KeyValuePairModelBinder<int, string>(CreateIntBinder(false), CreateStringBinder());
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.False(bindingContext.Result.IsModelSet);
Assert.Null(bindingContext.Result.Model);
Assert.False(bindingContext.ModelState.IsValid);
Assert.Equal("someName", bindingContext.ModelName);
var error = Assert.Single(bindingContext.ModelState["someName.Key"].Errors);
Assert.Equal("A value is required.", error.ErrorMessage);
}
public void BindModelWithBase64QuotedValueReturnsByteArray() {
// Arrange
string base64Value = Base64TestString;
SimpleValueProvider valueProvider = new SimpleValueProvider() {
{ "foo", "\"" + base64Value + "\"" }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ValueProvider = valueProvider
};
ByteArrayModelBinder binder = new ByteArrayModelBinder();
// Act
byte[] boundValue = binder.BindModel(null, bindingContext) as byte[];
// Assert
CollectionAssert.AreEqual(Base64TestBytes, boundValue);
}
public void BindModelWithBase64QuotedValueReturnsBinary() {
// Arrange
string base64Value = ByteArrayModelBinderTest.Base64TestString;
SimpleValueProvider valueProvider = new SimpleValueProvider() {
{ "foo", "\"" + base64Value + "\"" }
};
ModelBindingContext bindingContext = new ModelBindingContext() {
ModelName = "foo",
ValueProvider = valueProvider
};
LinqBinaryModelBinder binder = new LinqBinaryModelBinder();
// Act
Binary boundValue = binder.BindModel(null, bindingContext) as Binary;
// Assert
Assert.AreEqual(ByteArrayModelBinderTest.Base64TestBytes, boundValue);
}
public async Task BindModel_MissingValue_ReturnsResult_AndAddsModelValidationError()
{
// Arrange
var valueProvider = new SimpleValueProvider();
// Create int binder to create the value but not the key.
var bindingContext = GetBindingContext(valueProvider, CreateIntBinder());
var binder = new KeyValuePairModelBinder<int, string>();
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.Null(result.Model);
Assert.False(bindingContext.ModelState.IsValid);
Assert.Equal("someName", bindingContext.ModelName);
var state = bindingContext.ModelState["someName.Value"];
Assert.NotNull(state);
var error = Assert.Single(state.Errors);
Assert.Equal("A value is required.", error.ErrorMessage);
}
public async Task BindModelAsync_ValueProviderContainPrefix_Succeeds()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "84" },
};
var bindingContext = GetBindingContext(valueProvider);
var modelState = bindingContext.ModelState;
var binder = new ArrayModelBinder<int>(new SimpleTypeModelBinder());
// Act
var result = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotEqual(default(ModelBindingResult), result);
var array = Assert.IsType<int[]>(result.Model);
Assert.Equal(new[] { 42, 84 }, array);
}
public async Task BindComplexCollectionFromIndexes_InfiniteIndexes()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "100" },
{ "someName[3]", "400" }
};
var bindingContext = GetModelBindingContext(valueProvider);
var binder = new CollectionModelBinder<int>(CreateIntBinder());
// Act
var boundCollection = await binder.BindComplexCollectionFromIndexes(bindingContext, indexNames: null);
// Assert
Assert.Equal(new[] { 42, 100 }, boundCollection.Model.ToArray());
// This uses the default IValidationStrategy
Assert.DoesNotContain(boundCollection, bindingContext.ValidationState.Keys);
}
public async Task BindModelAsync_ModelMetadataNotReadOnly_ModelNonNull_FailsSilently(int[] model)
{
// Arrange
var arrayLength = model.Length;
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "84" },
};
var bindingContext = GetBindingContext(valueProvider);
bindingContext.Model = model;
var metadataProvider = new TestModelMetadataProvider();
metadataProvider.ForProperty(
typeof(ModelWithIntArrayProperty),
nameof(ModelWithIntArrayProperty.ArrayProperty)).BindingDetails(bd => bd.IsReadOnly = false);
bindingContext.ModelMetadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithIntArrayProperty),
nameof(ModelWithIntArrayProperty.ArrayProperty));
var binder = new ArrayModelBinder <int>(
new SimpleTypeModelBinder(typeof(int), NullLoggerFactory.Instance),
NullLoggerFactory.Instance);
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(bindingContext.Result.IsModelSet);
Assert.Same(model, bindingContext.Result.Model);
for (var i = 0; i < arrayLength; i++)
{
// Array should be unchanged.
Assert.Equal(357, model[i]);
}
}
public async Task BindModelAsync_SimpleCollectionWithNullValue_Succeeds()
{
// Arrange
var binder = new CollectionModelBinder <int>(CreateIntBinder());
var valueProvider = new SimpleValueProvider
{
{ "someName", null },
};
var bindingContext = GetModelBindingContext(valueProvider, isReadOnly: false);
// Act
var result = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotEqual(default(ModelBindingResult), result);
Assert.True(result.IsModelSet);
Assert.NotNull(result.Model);
var model = Assert.IsType <List <int> >(result.Model);
Assert.Empty(model);
}
public async Task BindModel_MissingKeyAndMissingValue_DoNotAddModelStateError()
{
// Arrange
var valueProvider = new SimpleValueProvider();
// Create int binder to create the value but not the key.
var bindingContext = GetBindingContext(valueProvider);
var mockBinder = new Mock<IModelBinder>();
mockBinder.Setup(o => o.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Returns(ModelBindingResult.NoResultAsync);
bindingContext.OperationBindingContext.ModelBinder = mockBinder.Object;
var binder = new KeyValuePairModelBinder<int, string>();
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.Equal(ModelBindingResult.NoResult, result);
Assert.True(bindingContext.ModelState.IsValid);
Assert.Equal(0, bindingContext.ModelState.ErrorCount);
}
public async Task BindModelAddsModelErrorsOnInvalidCharacters()
{
// Arrange
var expected = "The value '\"Fys1\"' is not valid for Byte[].";
var valueProvider = new SimpleValueProvider()
{
{ "foo", "\"Fys1\"" }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotNull(binderResult);
Assert.False(bindingContext.ModelState.IsValid);
var error = Assert.Single(bindingContext.ModelState["foo"].Errors);
Assert.Equal(expected, error.ErrorMessage);
}
public void BinderWithEmptyStringValueReturnsNull()
{
// Arrange
SimpleValueProvider valueProvider = new SimpleValueProvider()
{
{ "foo", "" }
};
ModelBindingContext bindingContext = new ModelBindingContext()
{
ModelName = "foo",
ValueProvider = valueProvider
};
LinqBinaryModelBinder binder = new LinqBinaryModelBinder();
// Act
object binderResult = binder.BindModel(null, bindingContext);
// Assert
Assert.Null(binderResult);
}
public async Task BindModelAsync_ValueProviderContainPrefix_Succeeds()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "84" },
};
var bindingContext = GetBindingContext(valueProvider);
var modelState = bindingContext.ModelState;
var binder = new ArrayModelBinder <int>(new SimpleTypeModelBinder());
// Act
var result = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotEqual(default(ModelBindingResult), result);
var array = Assert.IsType <int[]>(result.Model);
Assert.Equal(new[] { 42, 84 }, array);
}
public async Task BindModel_ReturnsWithIsModelSetFalse_WhenValueNotFound()
{
// Arrange
var valueProvider = new SimpleValueProvider()
{
{ "someName", "" }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder();
// Act
var binderResult = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotNull(binderResult);
Assert.False(binderResult.IsModelSet);
Assert.Equal("foo", binderResult.Key);
Assert.Null(binderResult.Model);
Assert.Empty(bindingContext.ModelState); // No submitted data for "foo".
}
public async Task BindModel_SimpleCollection_Succeeds(bool isReadOnly)
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName", new[] { "42", "100", "200" } }
};
var bindingContext = GetModelBindingContext(valueProvider, isReadOnly);
var modelState = bindingContext.ModelState;
var binder = new CollectionModelBinder <int>(CreateIntBinder());
// Act
var result = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotEqual(default(ModelBindingResult), result);
Assert.True(result.IsModelSet);
var list = Assert.IsAssignableFrom <IList <int> >(result.Model);
Assert.Equal(new[] { 42, 100, 200 }, list.ToArray());
}
public void BindModelWithNonExistentValueReturnsNull()
{
// Arrange
SimpleValueProvider valueProvider = new SimpleValueProvider()
{
{ "foo", null }
};
ModelBindingContext bindingContext = new ModelBindingContext()
{
ModelName = "foo",
ValueProvider = valueProvider
};
ByteArrayModelBinder binder = new ByteArrayModelBinder();
// Act
object binderResult = binder.BindModel(null, bindingContext);
// Assert
Assert.Null(binderResult);
}
public async Task BindComplexCollectionFromIndexes_FiniteIndexes()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[foo]", "42" },
{ "someName[baz]", "200" }
};
var bindingContext = GetModelBindingContext(valueProvider);
var binder = new CollectionModelBinder<int>(CreateIntBinder());
// Act
var collectionResult = await binder.BindComplexCollectionFromIndexes(
bindingContext,
new[] { "foo", "bar", "baz" });
// Assert
Assert.Equal(new[] { 42, 0, 200 }, collectionResult.Model.ToArray());
// This requires a non-default IValidationStrategy
var strategy = Assert.IsType<ExplicitIndexCollectionValidationStrategy>(collectionResult.ValidationStrategy);
Assert.Equal(new[] { "foo", "bar", "baz" }, strategy.ElementKeys);
}
public async Task BindModel_SimpleCollection_BindingContextModelNonNull_Succeeds(bool isReadOnly)
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName", new[] { "42", "100", "200" } }
};
var bindingContext = GetModelBindingContext(valueProvider, isReadOnly);
var modelState = bindingContext.ModelState;
var list = new List <int>();
bindingContext.Model = list;
var binder = new CollectionModelBinder <int>(CreateIntBinder(), NullLoggerFactory.Instance);
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.True(bindingContext.Result.IsModelSet);
Assert.Same(list, bindingContext.Result.Model);
Assert.Equal(new[] { 42, 100, 200 }, list.ToArray());
}
public void BindModelWithBase64UnquotedValueReturnsBinary()
{
// Arrange
string base64Value = ByteArrayModelBinderTest.Base64TestString;
SimpleValueProvider valueProvider = new SimpleValueProvider()
{
{ "foo", base64Value }
};
ModelBindingContext bindingContext = new ModelBindingContext()
{
ModelName = "foo",
ValueProvider = valueProvider
};
LinqBinaryModelBinder binder = new LinqBinaryModelBinder();
// Act
Binary boundValue = binder.BindModel(null, bindingContext) as Binary;
// Assert
Assert.Equal(ByteArrayModelBinderTest.Base64TestBytes, boundValue);
}
public async Task BindModelAddsModelErrorsOnInvalidCharacters()
{
// Arrange
var expected = "The value '\"Fys1\"' is not valid.";
var valueProvider = new SimpleValueProvider()
{
{ "foo", "\"Fys1\"" }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder(NullLoggerFactory.Instance);
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.False(bindingContext.Result.IsModelSet);
Assert.False(bindingContext.ModelState.IsValid);
var error = Assert.Single(bindingContext.ModelState["foo"].Errors);
Assert.Equal(expected, error.ErrorMessage);
}
public async Task BindModel_MissingValue_ReturnsResult_AndAddsModelValidationError()
{
// Arrange
var valueProvider = new SimpleValueProvider();
// Create int binder to create the value but not the key.
var bindingContext = GetBindingContext(valueProvider, typeof(KeyValuePair <int, string>));
var binder = new KeyValuePairModelBinder <int, string>(CreateIntBinder(), CreateStringBinder(false));
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.Null(bindingContext.Result.Model);
Assert.False(bindingContext.ModelState.IsValid);
Assert.Equal("someName", bindingContext.ModelName);
var state = bindingContext.ModelState["someName.Value"];
Assert.NotNull(state);
var error = Assert.Single(state.Errors);
Assert.Equal("A value is required.", error.ErrorMessage);
}
public void BindModelWithBase64QuotedValueReturnsByteArray()
{
// Arrange
string base64Value = Base64TestString;
SimpleValueProvider valueProvider = new SimpleValueProvider()
{
{ "foo", "\"" + base64Value + "\"" }
};
ModelBindingContext bindingContext = new ModelBindingContext()
{
ModelName = "foo",
ValueProvider = valueProvider
};
ByteArrayModelBinder binder = new ByteArrayModelBinder();
// Act
byte[] boundValue = binder.BindModel(null, bindingContext) as byte[];
// Assert
Assert.Equal(Base64TestBytes, boundValue);
}
public async Task BindModelSetsModelToNullOnNullOrEmptyString(string value)
{
// Arrange
var valueProvider = new SimpleValueProvider()
{
{ "foo", value }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder(NullLoggerFactory.Instance);
// Act
await binder.BindModelAsync(bindingContext);
// Assert
Assert.False(bindingContext.Result.IsModelSet);
Assert.Null(bindingContext.Result.Model);
var modelState = Assert.Single(bindingContext.ModelState);
Assert.Equal("foo", modelState.Key);
Assert.Equal(string.Empty, modelState.Value.RawValue);
}
public async Task BindComplexCollectionFromIndexes_FiniteIndexes()
{
// Arrange
var valueProvider = new SimpleValueProvider
{
{ "someName[foo]", "42" },
{ "someName[baz]", "200" }
};
var bindingContext = GetModelBindingContext(valueProvider);
var binder = new CollectionModelBinder <int>(CreateIntBinder(), NullLoggerFactory.Instance);
// Act
var collectionResult = await binder.BindComplexCollectionFromIndexes(
bindingContext,
new[] { "foo", "bar", "baz" });
// Assert
Assert.Equal(new[] { 42, 0, 200 }, collectionResult.Model.ToArray());
// This requires a non-default IValidationStrategy
var strategy = Assert.IsType <ExplicitIndexCollectionValidationStrategy>(collectionResult.ValidationStrategy);
Assert.Equal(new[] { "foo", "bar", "baz" }, strategy.ElementKeys);
}
private static DefaultModelBindingContext GetModelBindingContext(
bool isReadOnly,
IDictionary <string, string> values = null)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty <ModelWithIDictionaryProperty>(nameof(ModelWithIDictionaryProperty.DictionaryProperty))
.BindingDetails(bd => bd.IsReadOnly = isReadOnly);
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithIDictionaryProperty),
nameof(ModelWithIDictionaryProperty.DictionaryProperty));
var valueProvider = new SimpleValueProvider();
foreach (var kvp in values)
{
valueProvider.Add(kvp.Key, string.Empty);
}
var bindingContext = new DefaultModelBindingContext
{
ModelMetadata = metadata,
ModelName = "someName",
ModelState = new ModelStateDictionary(),
OperationBindingContext = new OperationBindingContext
{
MetadataProvider = metadataProvider,
ValueProvider = valueProvider,
},
ValueProvider = valueProvider,
ValidationState = new ValidationStateDictionary(),
};
return(bindingContext);
}
public async Task BindModelSetsModelToNullOnNullOrEmptyString(string value)
{
// Arrange
var valueProvider = new SimpleValueProvider()
{
{ "foo", value }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotNull(binderResult);
Assert.False(binderResult.IsModelSet);
Assert.Equal("foo", binderResult.Key);
Assert.Null(binderResult.Model);
var modelState = Assert.Single(bindingContext.ModelState);
Assert.Equal("foo", modelState.Key);
Assert.Equal(string.Empty, modelState.Value.RawValue);
}
public void ValueProviderProperty() {
// Arrange
ControllerBase controller = new ControllerBaseHelper();
IValueProvider valueProvider = new SimpleValueProvider();
// Act & assert
ValueProviderFactory[] originalFactories = ValueProviderFactories.Factories.ToArray();
try {
ValueProviderFactories.Factories.Clear();
MemberHelper.TestPropertyWithDefaultInstance(controller, "ValueProvider", valueProvider);
}
finally {
foreach (ValueProviderFactory factory in originalFactories) {
ValueProviderFactories.Factories.Add(factory);
}
}
}
public async Task BindModel_WithDefaultBinders_BindsSimpleType()
{
// Arrange
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleValueProvider
{
{ "firstName", "firstName-value"},
{ "lastName", "lastName-value"}
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(SimplePropertiesModel));
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotEqual(ModelBindingResult.NoResult, result);
var model = Assert.IsType<SimplePropertiesModel>(result.Model);
Assert.Equal("firstName-value", model.FirstName);
Assert.Equal("lastName-value", model.LastName);
}
public void UpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified() {
// Arrange
MyModel myModel = new MyModelSubclassed();
IValueProvider valueProvider = new SimpleValueProvider();
Controller controller = new EmptyController() { ValueProvider = valueProvider };
// Act
controller.UpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });
// Assert
Assert.AreEqual(valueProvider, myModel.BindingContext.ValueProvider);
}
public void TryUpdateModelCallsModelBinderForModel() {
// Arrange
MyModel myModel = new MyModelSubclassed();
IValueProvider valueProvider = new SimpleValueProvider();
Controller controller = new EmptyController();
controller.ControllerContext = GetControllerContext("someAction");
// Act
bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" }, null, valueProvider);
// Assert
Assert.IsTrue(returned);
Assert.AreEqual(valueProvider, myModel.BindingContext.ValueProvider);
Assert.AreEqual("somePrefix", myModel.BindingContext.ModelName);
Assert.AreEqual(controller.ModelState, myModel.BindingContext.ModelState);
Assert.AreEqual(typeof(MyModel), myModel.BindingContext.ModelType);
Assert.IsTrue(myModel.BindingContext.PropertyFilter("prop1"), "Incorrect filter applied.");
Assert.IsTrue(myModel.BindingContext.PropertyFilter("prop2"), "Incorrect filter applied.");
Assert.IsFalse(myModel.BindingContext.PropertyFilter("prop3"), "Incorrect filter applied.");
}
public async Task BindModel_ReturnsWithIsModelSetFalse_WhenValueNotFound()
{
// Arrange
var valueProvider = new SimpleValueProvider()
{
{ "someName", "" }
};
var bindingContext = GetBindingContext(valueProvider, typeof(byte[]));
var binder = new ByteArrayModelBinder();
// Act
var binderResult = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotNull(binderResult);
Assert.False(binderResult.IsModelSet);
Assert.Equal("foo", binderResult.Key);
Assert.Null(binderResult.Model);
Assert.Empty(bindingContext.ModelState); // No submitted data for "foo".
}
public async Task BindModel_WithDefaultBinders_BindsComplexType()
{
// Arrange
var binder = CreateBinderWithDefaults();
var valueProvider = new SimpleValueProvider
{
{ "firstName", "firstName-value"},
{ "lastName", "lastName-value"},
{ "friends[0].firstName", "first-friend"},
{ "friends[0].age", "40"},
{ "friends[0].friends[0].firstname", "nested friend"},
{ "friends[1].firstName", "some other"},
{ "friends[1].lastName", "name"},
{ "resume", "4+mFeTp3tPF=" }
};
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(Person));
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotEqual(ModelBindingResult.NoResult, result);
var model = Assert.IsType<Person>(result.Model);
Assert.Equal("firstName-value", model.FirstName);
Assert.Equal("lastName-value", model.LastName);
Assert.Equal(2, model.Friends.Count);
Assert.Equal("first-friend", model.Friends[0].FirstName);
Assert.Equal(40, model.Friends[0].Age);
var nestedFriend = Assert.Single(model.Friends[0].Friends);
Assert.Equal("nested friend", nestedFriend.FirstName);
Assert.Equal("some other", model.Friends[1].FirstName);
Assert.Equal("name", model.Friends[1].LastName);
Assert.Equal(new byte[] { 227, 233, 133, 121, 58, 119, 180, 241 }, model.Resume);
}
public async Task BindModel_DoesNotAddAValidationNode_IfModelBindingResultIsNoResult()
{
// Arrange
var mockBinder = new Mock<IModelBinder>();
mockBinder
.Setup(o => o.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Returns(ModelBindingResult.NoResultAsync);
var binder = CreateCompositeBinder(mockBinder.Object);
var valueProvider = new SimpleValueProvider();
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(SimplePropertiesModel));
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.Equal(ModelBindingResult.NoResult, result);
}
public async Task BindModel_UsesTheValidationNodeOnModelBindingResult_IfPresent()
{
// Arrange
var valueProvider = new SimpleValueProvider();
var mockBinder = new Mock<IModelBinder>();
mockBinder
.Setup(o => o.BindModelAsync(It.IsAny<ModelBindingContext>()))
.Returns((ModelBindingContext context) =>
{
return ModelBindingResult.SuccessAsync("someName", 42);
});
var binder = CreateCompositeBinder(mockBinder.Object);
var bindingContext = CreateBindingContext(binder, valueProvider, typeof(SimplePropertiesModel));
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotEqual(ModelBindingResult.NoResult, result);
Assert.True(result.IsModelSet);
}
public async Task BindModelAsync_ModelMetadataNotReadOnly_ModelNonNull_FailsSilently(int[] model)
{
// Arrange
var arrayLength = model.Length;
var valueProvider = new SimpleValueProvider
{
{ "someName[0]", "42" },
{ "someName[1]", "84" },
};
var bindingContext = GetBindingContext(valueProvider, isReadOnly: false);
var modelState = bindingContext.ModelState;
bindingContext.Model = model;
var binder = new ArrayModelBinder<int>(new SimpleTypeModelBinder());
// Act
var result = await binder.BindModelResultAsync(bindingContext);
// Assert
Assert.NotEqual(default(ModelBindingResult), result);
Assert.True(result.IsModelSet);
Assert.Same(model, result.Model);
for (var i = 0; i < arrayLength; i++)
{
// Array should be unchanged.
Assert.Equal(357, model[i]);
}
}
public async Task BindModel_SubBindingSucceeds()
{
// Arrange
var innerBinder = new CompositeModelBinder(new[] { CreateStringBinder(), CreateIntBinder() });
var valueProvider = new SimpleValueProvider();
var bindingContext = GetBindingContext(valueProvider, innerBinder);
var binder = new KeyValuePairModelBinder<int, string>();
// Act
var result = await binder.BindModelAsync(bindingContext);
// Assert
Assert.NotEqual(ModelBindingResult.NoResult, result);
Assert.Equal(new KeyValuePair<int, string>(42, "some-value"), result.Model);
}
public async Task TryBindStrongModel_InnerBinderReturnsAResult_ReturnsInnerBinderResult(
object model,
bool isSuccess)
{
// Arrange
ModelBindingResult innerResult;
if (isSuccess)
{
innerResult = ModelBindingResult.Success(model);
}
else
{
innerResult = ModelBindingResult.Failed();
}
var innerBinder = new StubModelBinder(context =>
{
Assert.Equal("someName.Key", context.ModelName);
return innerResult;
});
var valueProvider = new SimpleValueProvider();
var bindingContext = GetBindingContext(valueProvider, typeof(KeyValuePair<int, string>));
var binder = new KeyValuePairModelBinder<int, string>(innerBinder, innerBinder);
// Act
var result = await binder.TryBindStrongModel<int>(bindingContext, innerBinder, "Key", "someName.Key");
// Assert
Assert.Equal(innerResult, result);
Assert.Empty(bindingContext.ModelState);
}
public void TryUpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified()
{
// Arrange
MyModel myModel = new MyModelSubclassed();
IValueProvider valueProvider = new SimpleValueProvider();
Controller controller = new EmptyController();
controller.ValueProvider = valueProvider;
// Act
bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });
// Assert
Assert.True(returned);
Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
}
private static DefaultModelBindingContext GetModelBindingContext(
bool isReadOnly,
IDictionary<string, string> values = null)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider
.ForProperty<ModelWithIDictionaryProperty>(nameof(ModelWithIDictionaryProperty.DictionaryProperty))
.BindingDetails(bd => bd.IsReadOnly = isReadOnly);
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ModelWithIDictionaryProperty),
nameof(ModelWithIDictionaryProperty.DictionaryProperty));
var valueProvider = new SimpleValueProvider();
foreach (var kvp in values)
{
valueProvider.Add(kvp.Key, string.Empty);
}
var bindingContext = new DefaultModelBindingContext
{
ModelMetadata = metadata,
ModelName = "someName",
ModelState = new ModelStateDictionary(),
ValueProvider = valueProvider,
ValidationState = new ValidationStateDictionary(),
};
return bindingContext;
}
