public void Project_Orders_Custom_Expression_2()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>((o, mc) => new OrderDTO {
Id = o.OrderDetails.ToList().Select(od => od.OrderId).First(),
OrderNo = o.OrderNo,
Price = o.OrderDetails.Sum(od => od.UnitPrice),
OrderDetails = mc.MapToList <OrderDetail, OrderDetailDTO>(o.OrderDetails)
});
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var projector = config.GetProjector <Order, OrderDTO>(o => o.OrderDetails.Select(od => od.Product.Supplier));
var func = Helper.CreateProjector(projector);
var dtoList = _orders.Select(func).ToList();
Assert.AreEqual(
dtoList[3].Price,
_orders[3].OrderDetails.Sum(od => od.UnitPrice)
);
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
}
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 Project_Orders_With_Details_Product_Supplier_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 = o.Price
});
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var query = _orders.AsQueryable();
var dtoQuery = config.ProjectTo <Order, OrderDTO>(query, o => o.OrderDetails.Select(od => od.Product).Select(p => p.Supplier));
var dtoList = dtoQuery.ToList();
Assert.Equal(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
Assert.Null(dtoList[3].OrderDetails.ToList()[2].Product.Supplier.Addresses);
}
public void Project_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 = o.Price
});
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var projector = config.GetProjector <Order, OrderDTO>(o => o.OrderDetails.Select(od => od.Product.Supplier));
var func = Helper.CreateProjector(projector);
var dtoList = _orders.Select(func).ToList();
Assert.Equal(
dtoList[3].OrderDetails.ToList()[2].SubPrice,
_orders[3].OrderDetails[2].UnitPrice * _orders[3].OrderDetails[2].Count
);
Assert.Equal(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
}
public void Project_Orders_Custom_Expression2()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>((o, mc) => new OrderDTO {
Id = o.Id,
OrderNo = o.OrderNo,
// ReSharper disable once ConvertClosureToMethodGroup
// it will fail for method group because it must be an "Expression" to be handled
// mc.Map will be included in the final expression because we are using "Select" for "OrderDetails" navigation
// using "Select" is equal of saying "always map this property my way"
// if we want it to be dynamically decided for plural navigations we should have used: "mc.MapToList<OrderDetail, OrderDetailDTO>"
OrderDetails = o.OrderDetails.Select(od => mc.Map <OrderDetail, OrderDetailDTO>(od)).ToList(),
Price = o.Price
});
// similar custom mapping. but this time we need to register OrderDetail-OrderDetailDTO to allow MapContext to do the mapping
config.RegisterMap <OrderDetail, OrderDetailDTO>();
var query = _orders.AsQueryable();
var dtoQuery = config.ProjectTo <OrderDTO>(query, new IncludePath[] { });
var dtoList = dtoQuery.ToList();
Assert.NotNull(dtoList[3].OrderDetails);
Assert.Equal(dtoList[3].OrderDetails.Count, _orders[3].OrderDetails.Count);
Assert.True(dtoList.All(o => o.OrderDetails.All(od => od.Product == null)));
}
public void Project_Orders_With_Details_Product_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 = o.Price
});
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var mockContext = new Mock <TestEntities>();
var observableOrders = new ObservableCollection <Order>(_orders);
mockContext.Setup(p => p.Orders).Returns(GetMockSet(observableOrders).Object);
var query = mockContext.Object.Orders;
var dtoQuery = config.ProjectTo <Order, OrderDTO>(query, o => o.OrderDetails.Select(od => od.Product).Select(p => p.Supplier));
var dtoList = dtoQuery.ToList();
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].Product.Supplier.CompanyName,
_orders[3].OrderDetails[2].Product.Supplier.CompanyName
);
}
public void Project_Orders()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>();
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
var query = _orders.AsQueryable();
var dtoQuery = config.ProjectTo <OrderDTO>(query);
var dtoList = dtoQuery.ToList();
Assert.Null(dtoList[3].OrderDetails);
}
public void Project_Invalid_Method_Throws_Exception()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>((o, mc) => new OrderDTO {
Id = o.Id,
OrderNo = o.OrderNo,
Price = mc.MapToDictionary <int, OrderDetail, int, int>(o.OrderDetails.ToDictionary(od => od.Id, od => od)).Sum(x => x.Key)
});
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
Assert.Throws <InvalidOperationException>(() => config.GetProjector <Order, OrderDTO>(o => o.OrderDetails.Select(od => od.Product.Supplier)));
}
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 Project_Orders_Custom_Expression()
{
// we aren't registering OrderDetail-OrderDetailDTO because we declare the custom mapping
// even we don't include OrderDetail in the query, it will be mapped
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 = o.Price
});
var query = _orders.AsQueryable();
var dtoQuery = config.ProjectTo <OrderDTO>(query, new IncludePath[] { });
var dtoList = dtoQuery.ToList();
Assert.NotNull(dtoList[3].OrderDetails);
Assert.Equal(dtoList[3].OrderDetails.Count, _orders[3].OrderDetails.Count);
Assert.True(dtoList.All(o => o.OrderDetails.All(od => od.Product == null)));
}
public void Map_Order_To_Existing()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>();
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
config.RegisterMap <Company, CompanyDTO>();
var entity = _orders.First();
var dto = new OrderDTO();
var mapDto = config.MapTo(entity, dto);
Assert.Same(dto, mapDto);
Assert.Equal(dto.OrderDetails.Count, entity.OrderDetails.Count);
}
public void Project_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 = o.Price
});
var mockContext = new Mock <TestEntities>();
var observableOrders = new ObservableCollection <Order>(_orders);
mockContext.Setup(p => p.Orders).Returns(GetMockSet(observableOrders).Object);
var query = mockContext.Object.Orders;
var dtoQuery = config.ProjectTo <OrderDTO>(query, new IncludePath[] { });
var dtoList = dtoQuery.ToList();
Assert.IsNull(dtoList[3].OrderDetails);
}
public void Project_Orders_Custom_Expression()
{
// we aren't registering OrderDetail-OrderDetailDTO because we declare the custom mapping
// even we don't include OrderDetail in the query, it will be mapped
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 = o.Price
});
var mockContext = new Mock <TestEntities>();
var observableOrders = new ObservableCollection <Order>(_orders);
mockContext.Setup(p => p.Orders).Returns(GetMockSet(observableOrders).Object);
var query = mockContext.Object.Orders;
var dtoQuery = config.ProjectTo <OrderDTO>(query, new IncludePath[] { });
var dtoList = dtoQuery.ToList();
Assert.IsNotNull(dtoList[3].OrderDetails);
Assert.AreEqual(dtoList[3].OrderDetails.Count, _orders[3].OrderDetails.Count);
Assert.IsTrue(dtoList.All(o => o.OrderDetails.All(od => od.Product == null)));
}
public void Map_Existing_With_Non_MemberInitExpression()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>((c, mc) => mc.Map <Customer, CustomerDTO>(c));
Assert.Throws <InvalidOperationException>(() => config.MapTo(new Customer(), new CustomerDTO()));
}
public void Project_Orders_With_Navigations()
{
var config = new MapConfiguration(DynamicMapping.MapAndCache);
config.RegisterMap <OrderDetail, OrderDetailDTO>(b => b.SkipMember(od => od.Order));
config.RegisterMap <Product, ProductDTO>(b => b.SkipMember(p => p.Supplier));
var projector = config.GetProjector <Order, OrderDTO>();
var func = Helper.CreateProjector(projector);
var dtoList = _orders.Select(func).ToList();
Assert.AreEqual(
dtoList[3].OrderDetails.ToList()[2].Product.Id,
_orders[3].OrderDetails[2].Product.Id
);
}
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_Without_Destination_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map(null, true));
}
public void Map_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map(null, typeof(CustomerDTO)));
}
public void Map_Generic_With_Null()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>();
Assert.Null(config.Map <CustomerDTO>(null));
}
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_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_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_Collection_Property()
{
var entities = Give <ForTest5>
.ToMe(c => {
c.Cities = new Collection <City>(Give <City> .Many(10));
})
.Now(5);
entities[4].Cities = null;
var config = new MapConfiguration();
config.RegisterMap <ForTest5, ForTest5DTO>();
config.RegisterMap <City, CityDTO>();
var dtos = config.Map <ForTest5, ForTest5DTO>(entities).ToList();
Assert.True(dtos[3].Cities[2].Name == entities[3].Cities[2].Name);
Assert.Null(dtos[4].Cities);
}
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);
}
public void Project_Orders()
{
var config = new MapConfiguration();
config.RegisterMap <Order, OrderDTO>();
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
var mockContext = new Mock <TestEntities>();
var observableOrders = new ObservableCollection <Order>(_orders);
mockContext.Setup(p => p.Orders).Returns(GetMockSet(observableOrders).Object);
var query = mockContext.Object.Orders;
var dtoQuery = config.ProjectTo <OrderDTO>(query);
var dtoList = dtoQuery.ToList();
Assert.IsNull(dtoList[3].OrderDetails);
}
public void Register_Can_Access_Projector_Via_Interface()
{
var config = new MapConfiguration();
config.RegisterMap <Customer, CustomerDTO>(b => {
var builder = b as IMapBuilder <MapBuilder <Customer, CustomerDTO>, Customer, CustomerDTO>;
Assert.NotNull(builder);
Assert.NotNull(builder.GetProjector());
});
}
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_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_Dictionary_Property()
{
var config = new MapConfiguration();
config.RegisterMap <ForTest4, ForTest4DTO>();
config.RegisterMap <Order, OrderDTO>();
var entity = new ForTest4 {
Orders = new Dictionary <int, Order> {
{ 1, new Order {
Id = 1
} },
{ 2, new Order {
Id = 2
} }
}
};
var dto = config.Map <ForTest4DTO>(entity);
Assert.Equal(dto.Orders[2].Id, 2);
}
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);
}
