public void FromLambdaExpressionSetsContainerWithoutObjectInViewData()
{
// Arrange
Mock <ModelMetadataProvider> provider = new Mock <ModelMetadataProvider>();
DerivedModel derivedModel = new DerivedModel();
ViewDataDictionary <DerivedModel> viewData = new ViewDataDictionary <DerivedModel>();
provider.Setup(p => p.GetMetadataForProperty(It.IsAny <Func <object> >(), It.IsAny <Type>(), It.IsAny <string>()))
.Callback <Func <object>, Type, string>((accessor, type, propertyName) =>
{
Assert.Null(accessor());
Assert.Equal(derivedModel.GetType(), type);
Assert.Equal("MyProperty", propertyName);
})
.Returns <Func <object>, Type, string>((accessor, type, propertyName) =>
{
return(new ModelMetadata(provider.Object, derivedModel.GetType(), accessor, type, propertyName));
})
.Verifiable();
// Act
ModelMetadata metadata = ModelMetadata.FromLambdaExpression <DerivedModel, string>(m => m.MyProperty, viewData, provider.Object);
// Assert
provider.Verify();
Assert.Null(metadata.Container);
}
public async Task BindModelAsync_ForProperty_UsesValidationOnProperty_WhenDerivedModelIsSet()
{
// Arrange
var property = typeof(TestControllerWithValidatedProperties).GetProperty(nameof(TestControllerWithValidatedProperties.Model));
var parameterDescriptor = new ControllerBoundPropertyDescriptor
{
PropertyInfo = property,
Name = property.Name,
};
var actionContext = GetControllerContext();
var modelMetadataProvider = new TestModelMetadataProvider();
var model = new DerivedModel {
DerivedProperty = "some value"
};
var modelBindingResult = ModelBindingResult.Success(model);
var parameterBinder = new ParameterBinder(
modelMetadataProvider,
Mock.Of <IModelBinderFactory>(),
new DefaultObjectValidator(
modelMetadataProvider,
new[] { TestModelValidatorProvider.CreateDefaultProvider() },
new MvcOptions()),
_optionsAccessor,
NullLoggerFactory.Instance);
var modelMetadata = modelMetadataProvider.GetMetadataForProperty(property.DeclaringType, property.Name);
var modelBinder = CreateMockModelBinder(modelBindingResult);
// Act
var result = await parameterBinder.BindModelAsync(
actionContext,
modelBinder,
CreateMockValueProvider(),
parameterDescriptor,
modelMetadata,
value : null);
// Assert
Assert.True(result.IsModelSet);
Assert.Same(model, result.Model);
Assert.False(actionContext.ModelState.IsValid);
Assert.Collection(
actionContext.ModelState,
kvp =>
{
Assert.Equal($"{property.Name}", kvp.Key);
var error = Assert.Single(kvp.Value.Errors);
Assert.Equal("Always Invalid", error.ErrorMessage);
});
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
var model = new DerivedModel
{
DerivedProperty = bindingContext.ValueProvider.GetValue(nameof(DerivedModel.DerivedProperty)).FirstValue,
};
bindingContext.Result = ModelBindingResult.Success(model);
return(Task.CompletedTask);
}
public void CanSerializeBaseType()
{
DerivedModel payload = new DerivedModel {
A = "value", B = 5, C = true, D = null, E = "derived property"
};
BinaryData data = new BinaryData(jsonSerializable: payload, type: typeof(TestModel));
Assert.Null(data.ToObjectFromJson <DerivedModel>().E);
data = new BinaryData(jsonSerializable: payload, type: typeof(DerivedModel));
Assert.Equal("derived property", data.ToObjectFromJson <DerivedModel>().E);
data = new BinaryData(jsonSerializable: payload);
Assert.Equal("derived property", data.ToObjectFromJson <DerivedModel>().E);
data = BinaryData.FromObjectAsJson <TestModel>(payload);
Assert.Null(data.ToObjectFromJson <DerivedModel>().E);
data = BinaryData.FromObjectAsJson <DerivedModel>(payload);
Assert.Equal("derived property", data.ToObjectFromJson <DerivedModel>().E);
}
public void FromLambdaExpressionSetsContainerWithoutObjectInViewData()
{
// Arrange
Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
DerivedModel derivedModel = new DerivedModel();
ViewDataDictionary<DerivedModel> viewData = new ViewDataDictionary<DerivedModel>();
provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
.Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
{
Assert.Null(accessor());
Assert.Equal(derivedModel.GetType(), type);
Assert.Equal("MyProperty", propertyName);
})
.Returns<Func<object>, Type, string>((accessor, type, propertyName) =>
{
return new ModelMetadata(provider.Object, derivedModel.GetType(), accessor, type, propertyName);
})
.Verifiable();
// Act
ModelMetadata metadata = ModelMetadata.FromLambdaExpression<DerivedModel, string>(m => m.MyProperty, viewData, provider.Object);
// Assert
provider.Verify();
Assert.Null(metadata.Container);
}
public void Derived()
{
//-------------------------------------------------------------
// Verify that [BaseModel] works.
var baseModel = new BaseModel();
Assert.Null(baseModel.ParentProperty);
baseModel.ParentProperty = "Hello World!";
Assert.Equal("Hello World!", baseModel.ParentProperty);
baseModel = BaseModel.CreateFrom(baseModel.ToString());
Assert.Equal("Hello World!", baseModel.ParentProperty);
//-------------------------------------------------------------
// Verify that [DerivedModel] works too.
var derivedModel = new DerivedModel();
Assert.Null(derivedModel.ParentProperty);
Assert.Null(derivedModel.ChildProperty);
derivedModel.ParentProperty = "parent";
derivedModel.ChildProperty = "child";
derivedModel = DerivedModel.CreateFrom(derivedModel.ToString());
Assert.Equal("parent", derivedModel.ParentProperty);
Assert.Equal("child", derivedModel.ChildProperty);
//-------------------------------------------------------------
// Verify Equals():
var value1 = new DerivedModel()
{
ParentProperty = "parent", ChildProperty = "child"
};
var value2 = new DerivedModel()
{
ParentProperty = "parent", ChildProperty = "child"
};
Assert.True(value1.Equals(value1));
Assert.True(value1.Equals(value2));
Assert.True(value2.Equals(value1));
Assert.False(value1.Equals(null));
Assert.False(value1.Equals("Hello World!"));
// Verify that a change to the parent class property is detected.
value1.ParentProperty = "DIFFERENT";
Assert.True(value1.Equals(value1));
Assert.False(value1.Equals(value2));
Assert.False(value2.Equals(value1));
Assert.False(value1.Equals(null));
Assert.False(value1.Equals("Hello World!"));
// Verify that a change to the derived class property is detected.
value1.ParentProperty = "parent";
value1.ChildProperty = "DIFFERENT";
Assert.True(value1.Equals(value1));
Assert.False(value1.Equals(value2));
Assert.False(value2.Equals(value1));
Assert.False(value1.Equals(null));
Assert.False(value1.Equals("Hello World!"));
//-------------------------------------------------------------
// Verify that we can use [ToDerived<TResult>()] to create a derived instance
// from the base type. This also exercises [RoundtripDataFactory] a bit.
derivedModel = new DerivedModel()
{
ParentProperty = "parent", ChildProperty = "child"
};
baseModel = BaseModel.CreateFrom(derivedModel.ToString());
Assert.Equal("parent", baseModel.ParentProperty);
derivedModel = baseModel.ToDerived <DerivedModel>();
Assert.Equal("parent", derivedModel.ParentProperty);
Assert.Equal("child", derivedModel.ChildProperty);
}
public ActionResult <DerivedModel> PutModel(string userId, DerivedModel model) => null;
public void SetModel(DerivedModel model)
{
Model = model;
}
public void Run()
{
var model = new DerivedModel <DerivedRow>();
var parser = new DerivedParser <DerivedModel <DerivedRow>, DerivedRow>(model);
}
