public void Static_Api_Single()
{
var testModel = Give <TestModel> .Single();
Assert.NotNull(testModel);
Assert.Null(testModel.CompanyField);
Assert.Null(testModel.OrdersProp);
}
public void Instance_Api_Single()
{
var give = new Give();
var testModel = give.Single <TestModel>();
Assert.NotNull(testModel);
Assert.Null(testModel.CompanyField);
Assert.Null(testModel.OrdersProp);
}
public ExpressionTests()
{
var orders = Give <Order>
.ToMe(o => o.OrderDetails = Give <OrderDetail>
.ToMe(od => od.Product = Give <Product>
.ToMe(p => p.Supplier = Give <Company> .Single())
).Now(5)
).Now(20);
orders[3].Id = 5;
_query = orders.AsQueryable();
}
public StaticTests()
{
Customers = Give <Customer>
.ToMe(c => {
var addresses = Give <Address>
.ToMe(a => a.City = Give <City> .Single())
.Now(3);
c.Addresses = addresses;
c.MainAddress = addresses[0];
})
.Now(5);
}
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_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_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 ExpressionTests()
{
var orders = Give <Order>
.ToMe(o => o.Lines = Give <OrderLine>
.ToMe(od => {
od.OrderId = o.Id;
od.Order = o;
od.Product = Give <Product> .ToMe(p => p.Supplier = Give <Company> .Single());
}).Now(new Random().Next(3, 15))
).Now(20);
AvgId = orders.Average(o => o.Id);
_query = orders.AsQueryable();
}
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 = 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 = Give <Order> .Single();
var orderDetail = Give <OrderDetail> .Single();
order.OrderDetails = new List <OrderDetail> {
orderDetail
};
orderDetail.Order = order;
var orderDto = config.Map <OrderDTO>(order, true);
Assert.Equal(orderDto, orderDto.OrderDetails.First().Order);
}
public ComplexDataTests()
{
var random = new Random();
var products = Give <Product>
.ToMe(p => p.Supplier = Give <Company> .Single())
.Now(15);
_orders = Give <Order>
.ToMe(o => {
o.OrderDetails = Give <OrderDetail>
.ToMe(od => od.Product = products[random.Next(15)])
.Now(3);
})
.Now(10);
_orders[5].OrderDetails[1].Product = products[9];
_orders[7].OrderDetails[1].Product = products[9];
}
static Program()
{
var rnd = new Random();
_customers = Give <Customer> .ToMe()
.With(c => {
c.Addresses = Give <Address> .ToMe()
.With(a => a.City = Give <City> .Single())
.Now(rnd.Next(3) + 1);
c.Orders = Give <Order> .ToMe()
.With(o => o.OrderDetails = Give <OrderDetail> .Many(rnd.Next(5) + 1))
.Now(rnd.Next(10) + 1);
})
.Now(1000);
Mapper.RegisterMap <Customer, CustomerDTO>();
Mapper.RegisterMap <Address, AddressDTO>();
Mapper.RegisterMap <City, CityDTO>();
Mapper.RegisterMap <Order, OrderDTO>();
Mapper.RegisterMap <OrderDetail, OrderDetailDTO>();
global::AutoMapper.Mapper.Initialize(cfg => {
cfg.CreateMap <Customer, CustomerDTO>();
cfg.CreateMap <Address, AddressDTO>();
cfg.CreateMap <City, CityDTO>();
cfg.CreateMap <Order, OrderDTO>();
cfg.CreateMap <OrderDetail, OrderDetailDTO>();
});
#if NET
global::ExpressMapper.Mapper.Register <Customer, CustomerDTO>();
global::ExpressMapper.Mapper.Register <Address, AddressDTO>();
global::ExpressMapper.Mapper.Register <City, CityDTO>();
global::ExpressMapper.Mapper.Register <Order, OrderDTO>();
global::ExpressMapper.Mapper.Register <OrderDetail, OrderDetailDTO>();
Nelibur.ObjectMapper.TinyMapper.Bind <Customer, CustomerDTO>();
Nelibur.ObjectMapper.TinyMapper.Bind <Address, AddressDTO>();
Nelibur.ObjectMapper.TinyMapper.Bind <City, CityDTO>();
Nelibur.ObjectMapper.TinyMapper.Bind <Order, OrderDTO>();
Nelibur.ObjectMapper.TinyMapper.Bind <OrderDetail, OrderDetailDTO>();
#endif
}
public void Map_With_Preserve_References()
{
var config = new MapConfiguration();
config.RegisterMap <OrderDetail, OrderDetailDTO>();
config.RegisterMap <Product, ProductDTO>();
var orderDetail1 = Give <OrderDetail> .Single();
var orderDetail2 = Give <OrderDetail> .Single();
var product = Give <Product> .Single();
orderDetail1.Product = product;
orderDetail2.Product = product;
var orderDetails = new List <OrderDetail> {
orderDetail1, orderDetail2
};
var dtos = config.Map <OrderDetail, OrderDetailDTO>(orderDetails, true).ToList();
Assert.Equal(dtos[0].Product, dtos[1].Product);
}
public void Get_Property_Value()
{
var order = Give <Order> .Single();
Assert.Equal(Helper.GetPropertyValue(order, "OrderNo"), order.OrderNo);
}
public void Custom_String_Generated()
{
var company = _give.Single <Company>();
Assert.Equal(company.CompanyName, "DT");
}
public void Get_Field_Value()
{
var order = Give <Order> .Single();
Assert.Equal(Helper.GetFieldValue(order, "Price"), order.Price);
}