public void ConvertTestComplex()
{
var target = new PropertyConverter();
var source = new TestClassA {InnerClass = new TestClassC()};
const string expected = "test";
source.InnerClass.Name = expected;
var fromProperty = typeof (TestClassA).GetProperty("InnerClass");
var targetObject = new TestClassB {InnerClassName = "wrongstring"};
var toProperty = typeof (TestClassB).GetProperty("InnerClassName");
target.Convert(source, fromProperty, targetObject, toProperty);
Assert.AreEqual(expected, targetObject.InnerClassName);
Assert.AreEqual(expected, source.InnerClass.Name);
}
public void ConvertTestSimple()
{
var target = new PropertyConverter();
var source = new TestClassA();
const string expected = "test";
source.Name = expected;
var fromProperty = typeof (TestClassA).GetProperty("Name");
var targetObject = new TestClassB();
targetObject.Name = "wrongstring";
var toProperty = typeof (TestClassB).GetProperty("Name");
target.Convert(source, fromProperty, targetObject, toProperty);
Assert.AreEqual(expected, targetObject.Name);
Assert.AreEqual(expected, source.Name);
}
public void ConvertTestComplex()
{
PropertyConverter target = new PropertyConverter();
TestClassA source = new TestClassA();
source.InnerClass = new TestClassC();
var expected = "test";
source.InnerClass.Name = expected;
PropertyInfo fromProperty = typeof(TestClassA).GetProperty("InnerClass");
TestClassB targetObject = new TestClassB();
targetObject.InnerClassName = "wrongstring";
PropertyInfo toProperty = typeof(TestClassB).GetProperty("InnerClassName");
target.Convert(source, fromProperty, targetObject, toProperty);
Assert.AreEqual(expected, targetObject.InnerClassName);
Assert.AreEqual(expected, source.InnerClass.Name);
}
/// <summary>
/// Initializes a new instance of the <see cref="ReflectionPropertyMappingInfo<TSource, TTarget>" /> class.
/// </summary>
/// <param name="sourceProperty">The source property.</param>
/// <param name="targetProperty">The target property.</param>
/// <param name="strict">if set to <c>true</c>, performs a strict mapping.</param>
/// <param name="converter">The property converter to be used.</param>
public ReflectionPropertyMappingInfo(
PropertyInfo sourceProperty,
PropertyInfo targetProperty,
bool strict,
PropertyConverter converter)
{
Guard.CheckArgumentNotNull(sourceProperty, "sourceMemberName");
Guard.CheckArgumentNotNull(targetProperty, "targetMemberName");
Guard.CheckArgumentNotNull(converter, "converter");
SourceMemberName = sourceProperty.Name;
TargetMemberName = targetProperty.Name;
SourcePropertyInfo = sourceProperty;
TargetPropertyInfo = targetProperty;
Converter = converter;
Strict = strict;
}
protected Expression GetExpression(
string targetMemberName,
ReflectionPropertyMappingInfo <TSource, TTarget> reflectionInfo,
ParameterExpression sourceParameter,
ParameterExpression targetParameter)
{
Guard.CheckArgumentNotNull(reflectionInfo, "reflectionInfo");
var converter = new PropertyConverter();
return(converter.CreateConvertExpression(
reflectionInfo.SourcePropertyInfo,
reflectionInfo.TargetPropertyInfo,
sourceParameter,
targetParameter));
}
public void CreateConvertExpression_MultipleCases_ConvertsCorrectly(
Type sourceType,
Type targetType,
string sourcePropertyName,
string targetPropertyName,
object sourcePropertyValue)
{
var target = new PropertyConverter();
var fixture = new Fixture();
MethodInfo createMethod = fixture.GetType().GetMethod("CreateAnonymous");
object sourceObject = Activator.CreateInstance(sourceType);
object targetObject = Activator.CreateInstance(targetType);
ParameterExpression sourceParam = Expression.Parameter(sourceType);
ParameterExpression targetParam = Expression.Parameter(targetType);
PropertyInfo sourceProp = sourceType.GetProperty(sourcePropertyName);
PropertyInfo targetProp = targetType.GetProperty(targetPropertyName);
if (sourcePropertyValue != null)
{
sourceProp.SetValue(sourceObject, sourcePropertyValue, null);
}
var expr = target.CreateConvertExpression(
sourceProp,
targetProp,
sourceParam,
targetParam);
var actionType = typeof (MappingAction<,>).MakeGenericType(sourceType, targetType);
var lambda = Expression.Lambda(actionType, expr, sourceParam, targetParam);
var action = lambda.Compile();
action.DynamicInvoke(sourceObject, targetObject);
var resultProp = targetProp.GetValue(targetObject, null);
resultProp.ShouldBe(sourcePropertyValue);
}
private void TestMatch(string fromProp, string toProp, bool expected)
{
var target = new PropertyConverter();
var from = typeof (TestClassA).GetProperty(fromProp);
var to = typeof (TestClassB).GetProperty(toProp);
var actual = target.CanConvert(@from, to);
Assert.AreEqual(expected, actual);
}
public void PropertyConverterNegativeTest()
{
var target = new PropertyConverter();
var source = new TestClassA();
var sourceProperty = source.GetType().GetProperty("InnerClass");
var result = new TestClassB();
var resultProperty = result.GetType().GetProperty("InnerClassCode");
source.InnerClass = new TestClassC();
target.Convert(
source,
sourceProperty,
target,
resultProperty,
false);
}