public void Condition_Closure_Variable(bool isMapped)
{
bool captured = isMapped;
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(dest => dest.P1, opt => opt.Condition((ps, pd) => captured));
});
var mapper = config.CompileMapper();
int newValue = 1;
int originValue = 5;
var a = new A {
P1 = newValue
};
var b = new B {
P1 = originValue
};
mapper.Map(a, b);
int expected = isMapped ? newValue : originValue;
Assert.AreEqual(expected, b.P1);
}
public void Condition_SatisfiedWithMapFrom_MemberIsMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, X>().ForMember(d => d.P2, opt =>
{
opt.MapFrom(s => s.P1);
opt.Condition((s, d) => s.P1 + d.P2 < 0);
});
});
var mapper = config.CompileMapper();
int newValue = -10;
int originValue = 5;
var a = new A {
P1 = newValue
};
var x = new X {
P2 = originValue
};
mapper.Map(a, x);
Assert.AreEqual(newValue, x.P2);
}
public void Map_ListIsTarget_Success()
{
var config = new HappyConfig(cfg => cfg.CreateMap <Src, Dest>());
config.AssertConfigurationIsValid();
var mapper = config.CompileMapper();
var srcList = new List <Src>();
srcList.Add(new Src {
Value1 = Gen.Int()
});
srcList.Add(new Src {
Value1 = Gen.Int()
});
srcList.Add(new Src {
Value1 = Gen.Int()
});
List <Dest> destList = new List <Dest>();
destList.Add(new Dest());
destList.Add(new Dest());
destList.Add(new Dest());
mapper.Map(srcList, destList);
ObjectComparer.AreEqualCollections(srcList, destList);
}
public void Condition_NotSatisfiedOnASubClass_SubclassIsNotMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(dest => dest.P1, opt => opt.Condition((ps, pd) => ps.P1 + pd.P1 < 0));
cfg.CreateMap <C, D>();
});
var mapper = config.CompileMapper();
int newValue = 1;
int originValue = 5;
var a = new A {
P1 = newValue
};
var b = new B {
P1 = originValue
};
var c = new C {
A = a
};
var d = new D {
B = b
};
mapper.Map(c, d);
Assert.AreEqual(originValue, b.P1);
}
public void Map_ListIsMappedProperty_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
cfg.CreateMap <SrcWrap, DestWrap>();
});
config.AssertConfigurationIsValid();
var mapper = config.CompileMapper();
var srcList = new List <Src>();
srcList.Add(new Src {
Value1 = 1
});
List <Dest> destList = new List <Dest>();
destList.Add(new Dest());
SrcWrap srcWrap = new SrcWrap {
P1 = srcList
};
DestWrap destWrap = new DestWrap {
P1 = destList
};
mapper.Map(srcWrap, destWrap);
Assert.AreEqual(srcWrap.P1[0].Value1, destWrap.P1[0].Value1);
}
public void Ignore_IgnoreNotMappedDestinationMember_ConfigurationIsValid()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, C>().ForMember(d => d.P2, opt => opt.Ignore());
});
Assert.DoesNotThrow(() => config.AssertConfigurationIsValid());
}
private static void PrintPropertyMaps(HappyConfig config)
{
var propertyMaps = config.TypeMaps.Values.SelectMany(tm => tm.PropertyMaps).ToList();
foreach (var propertyMap in propertyMaps)
{
Console.WriteLine(propertyMap.ToString());
}
}
public void MapperConfiguration_CreateMap()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(d => d.MyProperty, opt => opt.Ignore());
cfg.CreateMap <C, D>().ForMember(d => d.MyProperty, opt => opt.MapFrom(s => s.MyProperty));
cfg.CreateMap <X, A>().ForMember(d => d.MyProperty, opt => opt.MapFrom(s => s.Foo));
});
PrintPropertyMaps(config);
}
private static SingleMapper <Src, Dest> CreateSingleMapper()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
});
var mapper = config.CompileMapper();
var singleMapper = mapper.GetSingleMapper <Src, Dest>();
return(singleMapper);
}
public void GetSingleMapper_NoMap_ThrowsEx()
{
Assert.Throws(Is.TypeOf <HappyMapperException>()
, () =>
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <NestedSrc, NestedDest>();
});
var mapper = config.CompileMapper();
var singleMapper = mapper.GetSingleMapper <Src, Dest>();
});
}
public Action <TSrc, TDest> CreateMapMethod <TSrc, TDest>()
where TSrc : class, new() where TDest : class, new()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <TSrc, TDest>();
});
var mapper = config.CompileMapper();
Action <TSrc, TDest> action = (src, dest) => mapper.Map(src, dest);
return(action);
}
public TDest Map <TSrc, TDest>(TSrc src) where TSrc : class, new() where TDest : class, new()
{
var config = new HappyConfig(cfg =>
cfg.CreateMap <TSrc, TDest>());
config.AssertConfigurationIsValid();
var mapper = config.CompileMapper();
TDest dest = new TDest();
mapper.Map(src, dest);
return(dest);
}
public void CreateCodeFiles_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>();
cfg.CreateMap <A1, B1>().ForMember(d => d.Id, opt => opt.Ignore());
cfg.CreateMap <A2, B2>();
});
var typeMaps = config.TypeMaps;
var mtb = new SingleFileBuilder(typeMaps, config.Configuration);
var files = mtb.Build().Files;
Print(files);
}
public void Before_and_After_should_be_called()
{
var beforeMapCalled = false;
var afterMapCalled = false;
var config = new HappyConfig(cfg => cfg.CreateMap <Source, Destination>()
.BeforeMap((src, dest) => beforeMapCalled = true)
//.AfterMap((src, dest) => afterMapCalled = true)
);
var mapper = config.CompileMapper();
mapper.Map(new Source(), new Destination());
Assert.IsTrue(beforeMapCalled);
//Assert.IsTrue(afterMapCalled);
}
public void Mapper_MapSimpleReferenceTypes_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
});
var mapper = config.CompileMapper();
var src = new Src();
var dest = new Dest();
mapper.Map(src, dest);
var result = ObjectComparer.AreEqual(src, dest);
Assert.IsTrue(result.Success);
}
public void Map_ListToLinkedList_Success()
{
var config = new HappyConfig(cfg => cfg.CreateMap <Src, Dest>());
config.AssertConfigurationIsValid();
var mapper = config.CompileMapper();
var src = new List <Src>();
src.Add(new Src {
Id = 1
});
var dest = mapper.Map <List <Src>, LinkedList <Dest> >(src);
ObjectComparer.AreEqualCollections(src, dest);
}
public void Mapper_MapNestedReferenceTypes_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <NestedSrc, NestedDest>();
});
var mapper = config.CompileMapper();
var src = new NestedSrc();
var dest = new NestedDest();
mapper.Map(src, dest);
var result = ObjectComparer.AreEqual(src, dest);
result.Errors.ForEach(Console.WriteLine);
Assert.IsTrue(result.Success);
}
public void CompileMapper_NoDestChildCtor_ThrowsEx()
{
Assert.Throws(Is.TypeOf <HappyMapperException>()
.And.Message.ContainsSubstring("parameterless ctor"),
delegate
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
});
var mapper = config.CompileMapper();
//var src = new Src();
//var dest = new Dest();
//mapper.Map(src, dest);
});
}
public void Mapper_MapSimpleTypes_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
});
var mapper = config.CompileMapper();
var src = new Src {
Id = 1
};
var dest = mapper.Map <Dest>(src);
var result = ObjectComparer.AreEqual(src, dest);
result.Errors.ForEach(Console.WriteLine);
Assert.IsTrue(result.Success);
}
public void Mapper_MapNullDestChild_CreatesObject()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
});
var mapper = config.CompileMapper();
var src = new Src {
Child = new SrcChild()
};
var dest = new Dest();
Assert.IsNull(dest.Child);
mapper.Map(src, dest);
Assert.IsNotNull(dest.Child);
}
public void MapFrom_SetMemberWithDifferentName_MemberIsMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(d => d.P2, opt => opt.MapFrom(s => s.P1));
});
var mapper = config.CompileMapper();
var a = new A {
P1 = 1
};
var b = new B {
P2 = 2
};
mapper.Map(a, b);
Assert.AreEqual(1, b.P2);
}
public void Ignore_IgnoreMappableDestinationMember_MemberIsNotMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(d => d.P1, opt => opt.Ignore());
});
var mapper = config.CompileMapper();
var a = new A {
P1 = 1
};
var b = new B {
P1 = 2
};
mapper.Map(a, b);
Assert.AreEqual(2, b.P1);
}
public void CreateText_RootLevelOnlyMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>();
});
var typeMaps = config.TypeMaps;
foreach (var kvp in typeMaps)
{
TypePair typePair = kvp.Key;
TypeMap map = kvp.Value;
var mtb = new MethodInnerCodeBuilder(typeMaps, config.Configuration);
string text = mtb.GetAssignment(map).RelativeTemplate;
Console.WriteLine(typePair.ToString());
Console.WriteLine(text);
Console.WriteLine();
}
}
public void Before_and_After_should_be_called()
{
var beforeMapCount = 0;
var afterMapCount = 0;
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Source, Destination>()
.BeforeMap((src, dest) => beforeMapCount++)
.BeforeMap((src, dest) => beforeMapCount++)
//.AfterMap((src, dest) => afterMapCount++)
//.AfterMap((src, dest) => afterMapCount++)
;
});
var mapper = config.CompileMapper();
mapper.Map(new Source(), new Destination());
Assert.AreEqual(2, beforeMapCount);
//afterMapCount.ShouldEqual(2);
}
public void Condition_Satisfied_MemberIsMapped()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(d => d.P1, opt => opt.Condition((s, d) => s.P1 + d.P1 < 0));
});
var mapper = config.CompileMapper();
int newValue = -10;
int originValue = 5;
var a = new A {
P1 = newValue
};
var b = new B {
P1 = originValue
};
mapper.Map(a, b);
Assert.AreEqual(newValue, b.P1);
}
public void CreateText_IgnoreAtSubLevel()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>();
cfg.CreateMap <A1, B1>().ForMember(d => d.Id, opt => opt.Ignore());
cfg.CreateMap <A2, B2>();
});
var typeMaps = config.TypeMaps;
var mtb = new MethodInnerCodeBuilder(typeMaps, config.Configuration);
foreach (var kvp in typeMaps)
{
TypePair typePair = kvp.Key;
TypeMap map = kvp.Value;
string text = mtb.GetAssignment(map).RelativeTemplate;
Console.WriteLine(typePair.ToString());
Console.WriteLine(text);
Console.WriteLine();
}
}
public void Condition_Closure_AnotherAssembly()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <A, B>().ForMember(dest => dest.P1, opt => opt.Condition((ps, pd) => GlobalContext.NegativeFlag));
});
var mapper = config.CompileMapper();
int newValue = 1;
int originValue = 5;
var a = new A {
P1 = newValue
};
var b = new B {
P1 = originValue
};
mapper.Map(a, b);
int expected = GlobalContext.NegativeFlag ? newValue : originValue;
Assert.AreEqual(expected, b.P1);
}
public void Mapper_MapNullDestList_CreatesList()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <SrcWrap, DestWrap>();
cfg.CreateMap <SrcChild, DestChild>();
});
var mapper = config.CompileMapper();
var src = new SrcWrap {
List = new List <SrcChild> {
new SrcChild {
P1 = 1
}
}
};
var dest = new DestWrap();
Assert.IsNull(dest.List);
mapper.Map(src, dest);
Assert.IsTrue(dest.List.Count > 0);
}
public void Map_ListOfLists_Success()
{
var config = new HappyConfig(cfg =>
{
cfg.CreateMap <Src, Dest>();
cfg.CreateMap <SrcWrapLevel2, DestWrapLevel2>();
});
config.AssertConfigurationIsValid();
var mapper = config.CompileMapper();
var srcListA = new List <Src>();
srcListA.Add(new Src {
Value1 = Gen.Int()
});
srcListA.Add(new Src {
Value1 = Gen.Int()
});
srcListA.Add(new Src {
Value1 = Gen.Int()
});
var srcListB = new List <Src>();
srcListB.Add(new Src {
Value1 = Gen.Int()
});
srcListB.Add(new Src {
Value1 = Gen.Int()
});
var srcListL2 = new List <List <Src> >();
srcListL2.Add(srcListA);
srcListL2.Add(srcListB);
var destList = new List <Dest>();
var destListL2 = new List <List <Dest> >();
destList.Add(new Dest());
destListL2.Add(destList);
var srcWrap = new SrcWrapLevel2 {
P1 = srcListL2
};
var destWrap = new DestWrapLevel2 {
P1 = destListL2
};
mapper.Map(srcWrap, destWrap);
//Mapper_SrcWrapLevel2_DestWrapLevel2_8bae.Map(srcWrap, destWrap);
for (int i = 0; i < srcWrap.P1.Count; i++)
{
for (int j = 0; j < srcWrap.P1[i].Count; j++)
{
var src = srcWrap.P1[i][j];
var dest = destWrap.P1[i][j];
var result = ObjectComparer.AreEqual(src, dest);
Assert.IsTrue(result.Success);
}
}
}
