public void Map_WithSimple_Succeeds()
{
//Arrange
var map = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().Map;
var entity = CommonHelper.CreateMainEntityWithSimpleProperties();
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
MainEntityModel[] array = ActMapping(entity, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
MainEntityModel model = array[i];
AssertEntityModel(entity, model);
}
}
public void Map_EnumerableWithDerivedWithSimple_Succeeds()
{
//Arrange
var map = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().Map;
var map2 = MapBuilder.Instance.CreateMap<DerivedMainEntity, DerivedMainEntityModel>().Map;
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
var derivedMainEntity = CommonHelper.CreateDerivedMainEntityWithSimpleProperties();
var entities = new MainEntity[]
{
mainEntity,
derivedMainEntity
};
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map2);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var array = ActEnumerableMapping(entities, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
var enumerable = array[i];
foreach (MainEntityModel current in enumerable)
{
if (current is DerivedMainEntityModel)
{
AssertEntityModel(derivedMainEntity, current);
}
else
{
AssertEntityModel(mainEntity, current);
}
}
}
}
public void Map_ThirdToSecondLevelFlattening_Succeeds()
{
//Arrange
var array = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubSubEntity, SubFlattenedThirdToSecondLevelModel>().Map
};
var array2 = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubEntity, SubFlattenedThirdToSecondLevelModel>()
.MapProperty((SubEntity p) => p.SubSubEntity, null, array).Map
};
var map = MapBuilder.Instance.CreateMap<MainEntity, FlattenedThirdToSecondLevelModel>()
.MapProperty((MainEntity p) => p.SubEntity, (FlattenedThirdToSecondLevelModel p) => p.SubEntityModel, array2).Map;
var mainEntity = CommonHelper.CreateMainEntityWithAllProperties(false);
var customMappingContext = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var flattenedThirdToSecondLevelModel = Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, customMappingContext);
var flattenedThirdToSecondLevelModel2 = Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, new FlattenedThirdToSecondLevelModel(), customMappingContext);
var flattenedThirdToSecondLevelModel3 = Mapper<MapperTesting.MapperTester>.Instance
.Map(mainEntity, typeof(FlattenedThirdToSecondLevelModel), customMappingContext) as FlattenedThirdToSecondLevelModel;
var array3 = new FlattenedThirdToSecondLevelModel[]
{
flattenedThirdToSecondLevelModel,
flattenedThirdToSecondLevelModel2,
flattenedThirdToSecondLevelModel3
};
//Assert
for (int i = 0; i < array3.Length; i++)
{
var flattenedThirdToSecondLevelModel4 = array3[i];
AssertSimpleFlattenedEntityModel(mainEntity.SubEntity.SubSubEntity,
flattenedThirdToSecondLevelModel4.SubEntityModel, "SubSubEntity");
}
}
public void Map_WithMapper_Succeeds()
{
//Arrange
var typeMap = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().As(
delegate(MainEntity source, MainEntityModel dest, TypeMappingContext ctxt)
{
dest.Simple = source.Simple;
dest.SimpleConverter = source.SimpleConverter.ToString();
});
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(typeMap);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var array = ActMapping(mainEntity, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
MainEntityModel mainEntityModel = array[i];
Assert.AreEqual<int>(mainEntity.Simple, mainEntityModel.Simple);
Assert.AreEqual<string>(mainEntity.SimpleConverter.ToString(), mainEntityModel.SimpleConverter);
}
}
public void Map_NestedWithPropertyMapsWithMappers_Succeeds()
{
//Arrange
var map = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().MapProperty((MainEntity p) => p.SubEntity,
delegate(MainEntity source, MainEntityModel dest, TypeMappingContext ctxt)
{
dest.SubEntity = new SubEntityModel();
dest.SubEntity.Simple = source.SubEntity.Simple;
dest.SubEntity.EntitySimpleNaming = source.SubEntity.SimpleNaming;
dest.SubEntity.EntitySimpleConverterNaming = source.SubEntity.SimpleConverterNaming.ToString();
}).Map;
var mainEntity = CommonHelper.CreateMainEntityWithAllProperties(false);
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
MainEntityModel[] array = ActMapping(mainEntity, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
var mainEntityModel = array[i];
Assert.AreEqual<int>(mainEntity.SubEntity.Simple, mainEntityModel.SubEntity.Simple);
Assert.AreEqual<int>(mainEntity.SubEntity.SimpleNaming, mainEntityModel.SubEntity.EntitySimpleNaming);
Assert.AreEqual<string>(mainEntity.SubEntity.SimpleConverterNaming.ToString(), mainEntityModel.SubEntity.EntitySimpleConverterNaming.ToString());
}
}
public void Map_NestedWithPropertyMapsWithSimple_Succeeds()
{
//Arrange
var array = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubSubEntity, SubSubEntityModel>().Map
};
var array2 = new TypeMap[]
{
MapBuilder.Instance.CreateMap<SubEntity, SubEntityModel>().MapProperty((SubEntity p) =>
p.SubSubEntity, (SubEntityModel p) => p.SubSubEntity, array).MapProperty((SubEntity p) =>
p.SubSubEntityArrayToArray, (SubEntityModel p) => p.SubSubEntityArrayToArray, array)
.MapProperty((SubEntity p) => p.SubSubEntityArrayToList, (SubEntityModel p) =>
p.SubSubEntityArrayToList, array).MapProperty((SubEntity p) => p.SubSubEntityListToArray,
(SubEntityModel p) => p.SubSubEntityListToArray, array).MapProperty((SubEntity p) =>
p.SubSubEntityListToList, (SubEntityModel p) => p.SubSubEntityListToList, array).Map
};
var map = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().MapProperty((MainEntity p) =>
p.SubEntity, (MainEntityModel p) => p.SubEntity, array2).MapProperty((MainEntity p) =>
p.SubEntityArrayToArray, (MainEntityModel p) => p.SubEntityArrayToArray, array2)
.MapProperty((MainEntity p) => p.SubEntityArrayToList, (MainEntityModel p) =>
p.SubEntityArrayToList, array2).MapProperty((MainEntity p) => p.SubEntityListToArray,
(MainEntityModel p) => p.SubEntityListToArray, array2).MapProperty((MainEntity p) =>
p.SubEntityListToList, (MainEntityModel p) => p.SubEntityListToList, array2).Map;
var entity = CommonHelper.CreateMainEntityWithAllProperties(false);
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
MainEntityModel[] array3 = ActMapping(entity, context);
//Asserts
for (int i = 0; i < array3.Length; i++)
{
MainEntityModel model = array3[i];
AssertEntityModel(entity, model);
}
}
public void Map_EnumerableWithDerivedWithMappers_Succeeds()
{
//Arrange
var typeMap = MapBuilder.Instance.CreateMap<MainEntity, MainEntityModel>().As(
delegate(MainEntity source, MainEntityModel dest, TypeMappingContext ctxt)
{
dest.Simple = source.Simple;
dest.SimpleConverter = source.SimpleConverter.ToString();
});
var typeMap2 = MapBuilder.Instance.CreateMap<DerivedMainEntity, DerivedMainEntityModel>().As(
delegate(DerivedMainEntity source, DerivedMainEntityModel dest, TypeMappingContext ctxt)
{
dest.Simple = source.Simple;
dest.SimpleConverter = source.SimpleConverter.ToString();
dest.DerivedSimple = source.DerivedSimple;
});
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
var derivedMainEntity = CommonHelper.CreateDerivedMainEntityWithSimpleProperties();
var entities = new MainEntity[]
{
mainEntity,
derivedMainEntity
};
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(typeMap);
Mapper<MapperTesting.MapperTester>.Instance.AddMap(typeMap2);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var array = ActEnumerableMapping(entities, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
var enumerable = array[i];
foreach (MainEntityModel current in enumerable)
{
if (current is DerivedMainEntityModel)
{
Assert.AreEqual<int>(derivedMainEntity.Simple, current.Simple);
Assert.AreEqual<string>(derivedMainEntity.SimpleConverter.ToString(), current.SimpleConverter);
Assert.AreEqual<int>(derivedMainEntity.DerivedSimple, ((DerivedMainEntityModel)current).DerivedSimple);
}
else
{
Assert.AreEqual<int>(mainEntity.Simple, current.Simple);
Assert.AreEqual<string>(mainEntity.SimpleConverter.ToString(), current.SimpleConverter);
}
}
}
}
public void Unmap_ThirdToSecondLevelFlattening_Succeeds()
{
//Arrange
var array = new ReversiveTypeMap[]
{
MapBuilder.Instance.CreateReversiveMap<SubSubEntity, SubFlattenedThirdToSecondLevelModel>().Map
};
var array2 = new ReversiveTypeMap[]
{
MapBuilder.Instance.CreateReversiveMap<SubEntity, SubFlattenedThirdToSecondLevelModel>()
.MapProperty((SubEntity p) => p.SubSubEntity, null, array).Map
};
var map = MapBuilder.Instance.CreateReversiveMap<MainEntity, FlattenedThirdToSecondLevelModel>()
.MapProperty((MainEntity p) => p.SubEntity, (FlattenedThirdToSecondLevelModel p) => p.SubEntityModel, array2).Map;
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
mainEntity.SubEntity = CommonHelper.CreateEntityWithSimpleProperties<SubEntity>();
mainEntity.SubEntity.SubSubEntity = CommonHelper.CreateEntityWithSimpleProperties<SubSubEntity>();
var customMappingContext = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var mainEntity2 = Mapper<MapperTesting.MapperTester>.Instance
.Unmap<MainEntity>(Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, customMappingContext), customMappingContext);
var mainEntity3 = Mapper<MapperTesting.MapperTester>.Instance
.Unmap<MainEntity>(Mapper<MapperTesting.MapperTester>.Instance
.Map<FlattenedThirdToSecondLevelModel>(mainEntity, new FlattenedThirdToSecondLevelModel(),
customMappingContext), new MainEntity(), customMappingContext);
var mainEntity4 = Mapper<MapperTesting.MapperTester>.Instance
.Unmap(Mapper<MapperTesting.MapperTester>.Instance
.Map(mainEntity, typeof(FlattenedThirdToSecondLevelModel),
customMappingContext), typeof(MainEntity), customMappingContext) as MainEntity;
//Assert
var array3 = new MainEntity[]
{
mainEntity2,
mainEntity3,
mainEntity4
};
for (int i = 0; i < array3.Length; i++)
{
AssertEntity(mainEntity.SubEntity.SubSubEntity, array3[i].SubEntity.SubSubEntity);
}
}
public void Unmap_NestedWithPropertyMapsWithSimple_Succeeds()
{
//Arrange
var array = new ReversiveTypeMap[]
{
MapBuilder.Instance.CreateReversiveMap<SubSubEntity, SubSubEntityModel>().Map
};
var array2 = new ReversiveTypeMap[]
{
MapBuilder.Instance.CreateReversiveMap<SubEntity, SubEntityModel>()
.MapProperty((SubEntity p) => p.SubSubEntity, (SubEntityModel p) => p.SubSubEntity, array)
.MapProperty((SubEntity p) => p.SubSubEntityArrayToArray,
(SubEntityModel p) => p.SubSubEntityArrayToArray, array)
.MapProperty((SubEntity p) => p.SubSubEntityArrayToList,
(SubEntityModel p) => p.SubSubEntityArrayToList, array)
.MapProperty((SubEntity p) => p.SubSubEntityListToArray,
(SubEntityModel p) => p.SubSubEntityListToArray, array)
.MapProperty((SubEntity p) => p.SubSubEntityListToList,
(SubEntityModel p) => p.SubSubEntityListToList, array).Map
};
var map = MapBuilder.Instance.CreateReversiveMap<MainEntity, MainEntityModel>()
.MapProperty((MainEntity p) => p.SubEntity, (MainEntityModel p) => p.SubEntity, array2)
.MapProperty((MainEntity p) => p.SubEntityArrayToArray,
(MainEntityModel p) => p.SubEntityArrayToArray, array2)
.MapProperty((MainEntity p) => p.SubEntityArrayToList,
(MainEntityModel p) => p.SubEntityArrayToList, array2)
.MapProperty((MainEntity p) => p.SubEntityListToArray,
(MainEntityModel p) => p.SubEntityListToArray, array2)
.MapProperty((MainEntity p) => p.SubEntityListToList,
(MainEntityModel p) => p.SubEntityListToList, array2).Map;
var mainEntity = CommonHelper.CreateMainEntityWithAllProperties(false);
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var result = ActUnmapping(mainEntity, context);
//Assert
for (int i = 0; i < result.Length; i++)
{
MainEntity actual = result[i];
AssertEntity(mainEntity, actual);
}
}
public void Unmap_EnumerableWithSimple_Succeeds()
{
//Arrange
var map = MapBuilder.Instance.CreateReversiveMap<MainEntity, MainEntityModel>().Map;
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
var entities = new MainEntity[]
{
mainEntity,
mainEntity
};
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(map);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var array = ActEnumerableUnmapping(entities, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
foreach (MainEntity current in array[i])
{
AssertEntity(mainEntity, current);
}
}
}
public void Unmap_EnumerableWithMapper_Succeeds()
{
//Arrange
var reversiveTypeMap = MapBuilder.Instance.CreateReversiveMap<MainEntity, MainEntityModel>()
.As(delegate(MainEntity source, MainEntityModel dest, TypeMappingContext ctxt)
{
dest.Simple = source.Simple;
dest.SimpleConverter = source.SimpleConverter.ToString();
}, delegate(MainEntityModel dest, MainEntity source, TypeMappingContext ctxt)
{
source.Simple = dest.Simple;
source.SimpleConverter = int.Parse(dest.SimpleConverter);
});
var mainEntity = CommonHelper.CreateMainEntityWithSimpleProperties();
var entities = new MainEntity[]
{
mainEntity,
mainEntity
};
var context = new MapperTesting.CustomMappingContext
{
Data = "data1"
};
Mapper<MapperTesting.MapperTester>.Instance.AddMap(reversiveTypeMap);
Mapper<MapperTesting.MapperTester>.Instance.Setup();
//Act
var array = ActEnumerableUnmapping(entities, context);
//Assert
for (int i = 0; i < array.Length; i++)
{
foreach (MainEntity current in array[i])
{
Assert.AreEqual<int>(mainEntity.Simple, current.Simple);
Assert.AreEqual<int>(mainEntity.SimpleConverter, current.SimpleConverter);
}
}
}
