public void GathersPropertiesInCtor()
{
var testee = new TypeMappingSpec <Target, Source>()
as ITypeMappingSpecProperties <Target, Source>
;
Assert.That(
testee.SourceProperties.Count(),
Is.EqualTo(2),
"Expected two SourceProperties.");
Assert.That(
testee.SourceProperties.All(x => x.DeclaringType == typeof(Source)),
"Expected SourceProperties to all have DeclaringType of Source."
);
Assert.That(
testee.SourceProperties.Select(x => x.Name),
Is.EquivalentTo(new[] { "Prop1", "Prop2" })
);
Assert.That(
testee.TargetProperties.Count(),
Is.EqualTo(2),
"Expected two TargetProperties.");
Assert.That(
testee.TargetProperties.All(x => x.DeclaringType == typeof(Target)),
"Expected TargetProperties to all have DeclaringType of Target."
);
Assert.That(
testee.TargetProperties.Select(x => x.Name),
Is.EquivalentTo(new[] { "Prop3", "Prop4" })
);
}
public void UnmatchedCustomITargetValueExceptionText()
{
var targetValue = new Mock <ITargetValue <SimpleTarget> >(MockBehavior.Strict);
targetValue.Setup(x => x.Description).Returns("DESC");
targetValue.Setup(x => x.PropertyName).Returns("Derp");
var mapper = FluentMapper
.ThatMaps <SimpleTarget>().From <SimpleSource>()
.ThatSets(tgt => tgt.B).From(src => src.A)
;
mapper = new TypeMappingSpec <SimpleTarget, SimpleSource>(
mapper.TargetValues.Concat(new[] { targetValue.Object }).ToArray(),
mapper.SourceValues.ToArray(),
mapper.CustomMappings.ToArray(),
mapper.ConstructorFunc,
mapper.Assembler
);
Assert.That(() => mapper.Create(), Throws.Exception);
try
{
mapper.Create();
}
catch (Exception ex)
{
Assert.AreEqual("Target DESC is unmatched.", ex.Message);
}
}
public void Ctor()
{
var spec = new TypeMappingSpec <Target, Source>();
var testee = spec.ThatSets(tgt => tgt.TargetProp)
as ISetterSpecProperties <Target, Source>
;
Assert.That(testee.Spec, Is.SameAs(spec));
Assert.That(testee.TargetProperty, Is.Not.Null);
Assert.That(testee.TargetProperty.Name, Is.EqualTo(nameof(Target.TargetProp)));
Assert.That(testee.TargetProperty.DeclaringType, Is.EqualTo(typeof(Target)));
}
WithTargetValues <TTarget, TSource>(
this TypeMappingSpec <TTarget, TSource> spec,
IEnumerable <ITargetValue <TTarget> > targetValues)
where TTarget : class
where TSource : class
{
return(new TypeMappingSpec <TTarget, TSource>(
targetValues.ToArray(),
spec.SourceValues.ToArray(),
spec.CustomMappings.ToArray(),
spec.ConstructorFunc,
spec.Assembler
));
}
public void MappingAction_Ctor()
{
var action = new Action <Target, Source>((tgt, src) => { /* no-op */ });
var testee = new TypeMappingSpec <Target, Source>()
.Transforms().WithSourceProperties(new PropertyInfo[0])
.Transforms().WithTargetProperties(new PropertyInfo[0])
.Transforms().WithMappingActions(new [] { action })
.Properties();
Assert.That(testee.MappingActions, Is.EqualTo(new[] { action }));
Assert.That(testee.SourceProperties, Is.Empty);
Assert.That(testee.TargetProperties, Is.Empty);
}
public void MappingActionOnly_Usage()
{
var called = false;
var action = new Action <Target, Source>((tgt, src) => called = true);
var testee = new TypeMappingSpec <Target, Source>()
.Transforms().WithTargetProperties(new PropertyInfo[0])
.Transforms().WithSourceProperties(new PropertyInfo[0])
.Transforms().WithMappingActions(new[] { action })
;
var mapper = testee.Create();
mapper.Map(new Source());
Assert.That(called, Is.True);
}
IgnoringNestedSourceProperty <TTarget, TSource>(
this TypeMappingSpec <TTarget, TSource> spec,
Expression sourceExpression)
where TTarget : class
where TSource : class
{
var visitor = new MemberVisitor <TSource>();
visitor.Visit(sourceExpression);
foreach (var expression in visitor.MemberExpressions)
{
spec = spec.IgnoringSourceProperty(expression.Member.Name);
}
return(spec);
}
WithCustomMapper <TTarget, TSource>(
this TypeMappingSpec <TTarget, TSource> spec,
Expression customMapper)
where TTarget : class
where TSource : class
{
return(new TypeMappingSpec <TTarget, TSource>(
spec.TargetValues.ToArray(),
spec.SourceValues.ToArray(),
new List <Expression>(spec.CustomMappings)
{
customMapper
}.ToArray(),
spec.ConstructorFunc,
spec.Assembler
));
}
public void PropertiesSubset_ViaCtor()
{
var testee =
new TypeMappingSpec <Target, Source>().Transforms()
.WithTargetProperties(
typeof(Target).GetProperties().Where(x => x.Name != "Prop3")
).Transforms()
.WithSourceProperties(
typeof(Source).GetProperties().Where(x => x.Name != "Prop1")
).Properties();
Assert.That(testee.SourceProperties.Count(), Is.EqualTo(1));
Assert.That(testee.TargetProperties.Count(), Is.EqualTo(1));
Assert.That(
testee.TargetProperties,
Has.Some.Matches <PropertyInfo>(x => x.Name == "Prop4"));
Assert.That(
testee.SourceProperties,
Has.Some.Matches <PropertyInfo>(x => x.Name == "Prop2"));
}
public void From_Creates_Mapping()
{
var result = new TypeMappingSpec <Target, Source>()
.ThatSets(tgt => tgt.TargetProp).From(src => src.SourceProp)
as ITypeMappingSpecProperties <Target, Source>
;
Assert.That(
result.SourceProperties,
Is.EqualTo(new[] { typeof(Source).GetProperty(nameof(Source.MatchingProp)) }));
Assert.That(
result.TargetProperties,
Is.EqualTo(new[] { typeof(Target).GetProperty(nameof(Target.MatchingProp)) }));
Assert.That(result.MappingActions.Count(), Is.EqualTo(1));
var target = new Target();
var source = new Source {
SourceProp = "value"
};
result.MappingActions.Single()(target, source);
Assert.That(target.TargetProp, Is.EqualTo(source.SourceProp));
}
public void MultipleMappings()
{
var result = new TypeMappingSpec <Target, Source>()
.ThatSets(tgt => tgt.TargetProp).From(src => src.SourceProp)
.ThatSets(tgt => tgt.MatchingProp).From(src => src.MatchingProp)
as ITypeMappingSpecProperties <Target, Source>
;
Assert.That(result.SourceProperties, Is.Empty);
Assert.That(result.TargetProperties, Is.Empty);
Assert.That(result.MappingActions.Count(), Is.EqualTo(2));
var source = new Source {
MatchingProp = 7
};
var target = new Target();
foreach (var action in result.MappingActions)
{
action(target, source);
}
Assert.That(target.MatchingProp, Is.EqualTo(7));
}
Properties <TTgt, TSrc>(this TypeMappingSpec <TTgt, TSrc> spec)
{
return(spec);
}
Transforms <TTgt, TSrc>(this TypeMappingSpec <TTgt, TSrc> spec)
{
return(spec);
}
protected override TypeMappingSpec <Target, Source> Configure(TypeMappingSpec <Target, Source> mappingSpec)
{
return(mappingSpec
.ThatSets(tgt => tgt.Bar).From(src => 11));
}
