public void ReversiveTypeMap_GoodValues_Succeeds()
{
//Arrange
//Act
var reversiveTypeMap = new ReversiveTypeMap(typeof(string), typeof(int));
//Assert
Assert.AreEqual<Type>(typeof(string), reversiveTypeMap.SourceType);
Assert.AreEqual<Type>(typeof(int), reversiveTypeMap.DestinationType);
}
public void PropertyMaps_Initially_IsEmpty()
{
//Arrange
var reversiveTypeMap = new ReversiveTypeMap(typeof(string), typeof(int));
//Act
var propertyMaps = reversiveTypeMap.PropertyMaps;
//Assert
Assert.AreEqual<int>(0, propertyMaps.Count);
}
public void Validate_IfTypeMapperOrTypeUnMapperIsNotDefined_OnlyUnMapper_ThrowsMapValidationException()
{
ReversiveTypeMap reversiveTypeMap = new ReversiveTypeMap(typeof(MainEntity), typeof(MainEntityModel));
reversiveTypeMap.set_UnMapper(delegate(object source, object dest, TypeMappingContext context)
{
});
TypeMapBase[] array = new TypeMapBase[]
{
reversiveTypeMap
};
new MapValidator().Validate(reversiveTypeMap, array);
}
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 Validate_IfTypeMapperOrTypeUnMapperIsNotDefined_OnlyUnMapper_ThrowsMapValidationException()
{
//Arrange
var reversiveTypeMap = new ReversiveTypeMap(typeof(MainEntity), typeof(MainEntityModel));
reversiveTypeMap.UnMapper = delegate(object source, object dest, TypeMappingContext context)
{
};
var array = new TypeMapBase[]
{
reversiveTypeMap
};
//Act
//Assert
new MapValidator().Validate(reversiveTypeMap, array);
}
public static void MapValidationException_IfTypeMapperOrTypeUnMapperIsNotDefined(ReversiveTypeMap map)
{
if ((map.Mapper == null && map.UnMapper != null) || (map.Mapper != null && map.UnMapper == null))
{
throw new MapValidationException(string.Format(Resources.TypeMapperOrTypeUnMapperIsNotDefined1,
(map != null) ? map.ToString() : string.Empty), null);
}
}
