public void Map_Two_Generic_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>(b => b.MapMember(c => c.Address, (c, mc) => mc.Map <Address, AddressDTO>(c.MainAddress)));
Assert.Null(config.Map <Customer, CustomerDTO>((Customer)null));
Assert.Null(config.Map <Customer, CustomerDTO>(new Customer()).Address);
}
public void Map_Orders_Custom_Expression()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>((o, mc) => new OrderDTO {
Id = o.Id,
OrderNo = o.OrderNo,
OrderDetails = o.OrderDetails.Select(od => new OrderDetailDTO {
Id = od.Id,
Product = mc.Map <Product, ProductDTO>(od.Product),
SubPrice = od.UnitPrice * od.Count
}).ToList(),
Price = Math.Round(o.Price)
});
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var dtoList = config.Map <Order, OrderDTO>(_orders).ToList();
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].SubPrice,
_orders[3].OrderDetails[2].UnitPrice * _orders[3].OrderDetails[2].Count
);
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
}
public void Map_With_Non_MemberInitExpression()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>((c, mc) => null);
Assert.Null(config.Map <CustomerDTO>(new Customer(), true));
}
public void Map_Empty_Dictionary_Returns_Empty()
{
var config = new MapConfiguration();
var dict = new Dictionary <int, Customer>();
Assert.Equal(config.Map <int, Customer, int, CustomerDTO>(dict).Count, 0);
}
public void Map_Generic_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map <CustomerDTO>(null));
}
public void Map_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map(null, typeof(CustomerDTO)));
}
public void Map_Without_Destination_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map(null, true));
}
public void Map_Enumerable_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map <Customer, CustomerDTO>((IEnumerable <Customer>)null));
}
public void Map_Nullable_Conversation_When_Value_Null()
{
var config = new MapConfiguration();
config.RegisterMap <ForTest9, ForTest9DTO>();
var model = new ForTest9();
var dto = config.Map <ForTest9, ForTest9DTO>(model);
Assert.Equal(dto.Amount, null);
}
public void Map_Orders_PreserveReferences()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
var dtoList = config.Map <Order, OrderDTO>(_orders, true).ToList();
Assert.AreEqual(
dtoList[5].OrderDetails.ToList()[1].Product,
dtoList[7].OrderDetails.ToList()[1].Product
);
}
public void Map_Orders()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
var dtoList = config.Map <Order, OrderDTO>(_orders).ToList();
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
}
public void Map_With_Empty_Collection()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
var customer = new Customer();
var dto = config.Map <CustomerDTO>(customer);
Assert.Equal(dto.Orders.Count, 0);
}
public void Map_With_NonList()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
var customers = Give <Customer> .Many(5);
var dtos = config.Map <Customer, CustomerDTO>(customers);
Assert.Equal(dtos.Count(), 5);
}
public void Register_With_Type_Cast()
{
var config = new MapConfiguration();
config.RegisterMap <ForTest2, ForTest2DTO>();
var dto = config.Map <ForTest2DTO>(new ForTest2 {
Number = 5
});
Assert.Equal(dto.Number, 5);
}
public void Map_For_Constructor_With_Parameter()
{
var config = new MapConfiguration();
config.RegisterMap <ForTest8, ForTest8DTO>((e, mc) => new ForTest8DTO(e.Id, e.Name));
var model = new ForTest8(42, "Zaphod");
var dto = config.Map <ForTest8, ForTest8DTO>(model);
Assert.Equal(42, dto.Id);
Assert.Equal("Zaphod", dto.Name);
}
public void Map_With_NonList()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
var customers = Builder <Customer> .CreateListOfSize(5).Build().Select(c => c);
var dtos = config.Map <Customer, CustomerDTO>(customers);
Assert.AreEqual(dtos.Count(), 5);
}
public void Map_Orders_PreserveReferences_Enumerable()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
config.RegisterMap <Order, OrderDTO>();
var dtoList = config.Map(_orders, true);
Assert.Equal(
((OrderDTO)dtoList[5]).OrderDetails.ToList()[1].Product,
((OrderDTO)dtoList[7]).OrderDetails.ToList()[1].Product
);
}
public void Map_Orders_With_SkipMember()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>(b => {
b.SkipMember(o => o.Price);
});
var order = Builder <Order> .CreateNew().Build();
var orderDto = config.Map <OrderDTO>(order);
Assert.AreNotEqual(order.Price, orderDto.Price);
}
public void Map_Orders_With_MapMember()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>(b => {
b.MapMember(o => o.Price, (o, mc) => o.Price * 3);
});
var order = Builder <Order> .CreateNew().Build();
var orderDto = config.Map <OrderDTO>(order);
Assert.IsTrue(orderDto.Price.Equals(order.Price * 3));
}
public void Map_Orders_With_MapMember()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>(b => {
b.MapMember(o => o.Price, (o, mc) => o.Price * 3);
});
var order = Give <Order> .Single();
var orderDto = config.Map <OrderDTO>(order);
Assert.True(orderDto.Price.Equals(order.Price * 3));
}
public void Map_Orders_With_SkipMember()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>(b => {
b.SkipMember(o => o.Price);
});
var order = Give <Order> .Single();
var orderDto = config.Map <OrderDTO>(order);
Assert.NotEqual(order.Price, orderDto.Price);
}
public void Map_Orders_With_SkipMember_String()
{
var config = new MapConfiguration();
config.RegisterMap(typeof(Order), typeof(OrderDTO), b => {
b.SkipMember("Price");
});
var order = Give <Order> .Single();
var orderDto = config.Map <OrderDTO>(order);
Assert.NotEqual(order.Price, orderDto.Price);
}
public void Map_Orders_PreserveReferences_Enumerable_AutoDetect()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
config.RegisterMap <Order, OrderDTO>();
var orders = (object)_orders;
var dtoList = ((List <object>)config.Map(orders, true)).Cast <OrderDTO>().ToList();
Assert.Equal(
((OrderDTO)dtoList[5]).OrderDetails.ToList()[1].Product,
((OrderDTO)dtoList[7]).OrderDetails.ToList()[1].Product
);
}
public void Map_Orders_With_MapMember_String()
{
var config = new MapConfiguration();
config.RegisterMap <OrderDTO, Order>();
config.RegisterMap(typeof(OrderDetailDTO), typeof(OrderDetail), b => {
b.MapMember("OrderId", "Order.Id");
});
var orderDetailDto = Give <OrderDetailDTO> .ToMe().With(od => od.Order = Give <OrderDTO> .Single()).Now();
var orderDetail = config.Map <OrderDetail>(orderDetailDto);
Assert.True(orderDetail.OrderId.Equals(orderDetailDto.Order.Id));
}
public void Map_Dictionary_With_Class_Key()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
var customer = Builder <Customer> .CreateNew().Build();
var dict = new Dictionary <Customer, int> {
{ customer, customer.Id }
};
var dtoDict = config.Map <Customer, int, CustomerDTO, int>(dict);
Assert.AreEqual(customer.Id, dtoDict.First().Key.Id);
}
public void Map_Dictionary_With_Class_Key()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
var customer = Give <Customer> .Single();
var dict = new Dictionary <Customer, int> {
{ customer, customer.Id }
};
var dtoDict = config.Map <Customer, int, CustomerDTO, int>(dict);
Assert.Equal(customer.Id, dtoDict.First().Key.Id);
}
public void Map_Orders_PreserveReferences_2()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
var order = Builder <Order> .CreateNew().Build();
var orderDetail = Builder <OrderDetail> .CreateNew().Build();
order.OrderDetails = new List <OrderDetail> {
orderDetail
};
orderDetail.Order = order;
var orderDto = config.Map <OrderDTO>(order, true);
Assert.AreEqual(orderDto, orderDto.OrderDetails.First().Order);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
MapConfiguration.Map(modelBuilder.Entity <DateBoundTimeRanges>());
MapConfiguration.Map(modelBuilder.Entity <DayOff>());
MapConfiguration.Map(modelBuilder.Entity <TreatmentPerformer>());
MapConfiguration.Map(modelBuilder.Entity <Booking>());
MapConfiguration.Map(modelBuilder.Entity <TimeRange>());
MapConfiguration.Map(modelBuilder.Entity <Address>());
MapConfiguration.Map(modelBuilder.Entity <Costumer>());
MapConfiguration.Map(modelBuilder.Entity <Employee>());
MapConfiguration.Map(modelBuilder.Entity <BookingManagement>());
MapConfiguration.Map(modelBuilder.Entity <Company>());
MapConfiguration.Map(modelBuilder.Entity <Treatment>());
MapConfiguration.Map(modelBuilder.Entity <Costumer>());
MapConfiguration.Map(modelBuilder.Entity <ScheduleBaseSettings>());
MapConfiguration.Map(modelBuilder.Entity <Schedule>());
}
public void Map_To_Collection_Property()
{
var entity = Give <ForTest5>
.ToMe(c => {
c.Cities = new Collection <City>(Give <City> .Many(10));
})
.Now();
var config = new MapConfiguration();
config.RegisterMap <ForTest5, ForTest5DTO>((e, mc) => new ForTest5DTO {
Cities = mc.MapToCollection <City, CityDTO>(e.Cities)
});
config.RegisterMap <City, CityDTO>();
var dto = config.Map <ForTest5, ForTest5DTO>(entity);
Assert.True(dto.Cities[2].Name == entity.Cities[2].Name);
}
public void Map_HashSet_Property()
{
var entities = Give <ForTest6>
.ToMe(c => {
c.Cities = new HashSet <City>(Give <City> .Many(10));
})
.Now(5);
entities[4].Cities = null;
var config = new MapConfiguration();
config.RegisterMap <ForTest6, ForTest6DTO>();
config.RegisterMap <City, CityDTO>();
var dtos = config.Map <ForTest6, ForTest6DTO>(entities).ToList();
Assert.True(dtos[3].Cities.First().Name == entities[3].Cities.First().Name);
Assert.Null(dtos[4].Cities);
}
