private ItemPriceAndCurrencyResponseDTO MapManuallyFromModelToDto(ItemPriceAndCurrencyResponse model)
{
var dto = _mapper.Map <ItemPriceAndCurrencyResponseDTO>(model);
if (model.Groups != null)
{
dto.Groups = new List <GroupsDTO>();
}
foreach (var group in model.Groups)
{
var groupDTO = _mapper.Map <GroupsDTO>(group);
if (group.Item != null)
{
groupDTO.Items = new List <ItemDTO>();
}
dto.Groups.Add(groupDTO);
foreach (var item in group.Item)
{
var itemDTO = _mapper.Map <ItemDTO>(item);
if (item.ItemDay != null)
{
itemDTO.ItemDays = new List <ItemDayDTO>();
}
groupDTO.Items.Add(itemDTO);
foreach (var itemDay in item.ItemDay)
{
var itemDayDTO = _mapper.Map <ItemDayDTO>(itemDay);
itemDTO.ItemDays.Add(itemDayDTO);
}
}
}
return(dto);
}
public void MapFromContext_ExistingFromGroupsTest()
{
//Arrange Dependencies
var mapperMock = new Mock <IMapper>();
var serviceContextMock = new Mock <PriceCalendarServiceContext>();
var consumeContextMock = new Mock <ConsumeContext <IItemEntityCreated> >();
var loggerMock = new Mock <ILogger>();
var creationOfItemEntityConsumer = new CreationOfItemEntityConsumer(serviceContextMock.Object, mapperMock.Object, loggerMock.Object);
//Arrange Mocked object
consumeContextMock.Setup(p => p.Message.ArticleGroup).Returns(2222);
consumeContextMock.Setup(p => p.Message.ItemNo).Returns("ItemNo");
consumeContextMock.Setup(p => p.Message.Name).Returns("Name");
consumeContextMock.Setup(p => p.Message.RelationNo).Returns(3333);
consumeContextMock.Setup(p => p.Message.Unit).Returns("Unit");
consumeContextMock.Setup(p => p.Message.Price).Returns(1111);
//Setup argument for existing found in db
var existing = new ItemPriceAndCurrencyResponse
{
Id = consumeContextMock.Object.Message.RelationNo ?? default(int),
Currency = consumeContextMock.Object.Message.Unit
};
//Setup desired result from tested method
var desiredGroup = new Groups
{
Currency = existing,
CurrencyId = existing.Id,
Id = consumeContextMock.Object.Message.ArticleGroup ?? default(int),
Item = new List <Item>()
};
var item = new Item
{
Group = desiredGroup,
GroupId = desiredGroup.Id,
Id = consumeContextMock.Object.Message.ItemNo,
Name = consumeContextMock.Object.Message.Name,
Price = consumeContextMock.Object.Message.Price
};
var resultGroup = creationOfItemEntityConsumer
.MapFromContext_ExistingFromGroups(consumeContextMock.Object, existing);
Assert.AreEqual(desiredGroup.Currency, resultGroup.Currency);
Assert.AreEqual(desiredGroup.CurrencyId, resultGroup.CurrencyId);
Assert.AreEqual(desiredGroup.Id, resultGroup.Id);
foreach (var gItem in resultGroup.Item)
{
//Assert.AreEqual(item.Group, gItem.Group); -> Assert does not work at all with complex objects (they are the same)
Assert.AreEqual(item.GroupId, gItem.GroupId);
Assert.AreEqual(item.Id, gItem.Id);
Assert.AreEqual(item.Name, gItem.Name);
Assert.AreEqual(item.Price, gItem.Price);
}
}
public void MapFromContext(ConsumeContext <IItemEntityUpdated> from, ItemPriceAndCurrencyResponse to)
{
to.Currency = from.Message.Unit;
foreach (var group in to.Groups)
{
if (group.Id == from.Message.ArticleGroup)
{
MapFromContext(from, group);
}
}
}
public ItemPriceAndCurrencyResponse MapFromContext_NonExisting(ConsumeContext <IItemEntityCreated> from)
{
var itemPriceAndCurrencyResponse = new ItemPriceAndCurrencyResponse
{
Id = from.Message.RelationNo ?? default(int),
Currency = from.Message.Unit
};
itemPriceAndCurrencyResponse.Groups = new List <Groups>();
itemPriceAndCurrencyResponse.Groups.Add(this.MapFromContext_ExistingFromGroups(from, itemPriceAndCurrencyResponse));
return(itemPriceAndCurrencyResponse);
}
public void MapFromContext_ExistingFromResponseTest()
{
//Arrange Dependencies
var mapperMock = new Mock <IMapper>();
var serviceContextMock = new Mock <PriceCalendarServiceContext>();
var consumeContextMock = new Mock <ConsumeContext <IItemEntityCreated> >();
var loggerMock = new Mock <ILogger>();
var creationOfItemEntityConsumer = new CreationOfItemEntityConsumer(serviceContextMock.Object, mapperMock.Object, loggerMock.Object);
//Arrange Mocked object
consumeContextMock.Setup(p => p.Message.ArticleGroup).Returns(2222);
consumeContextMock.Setup(p => p.Message.ItemNo).Returns("ItemNo");
consumeContextMock.Setup(p => p.Message.Name).Returns("Name");
consumeContextMock.Setup(p => p.Message.RelationNo).Returns(3333);
consumeContextMock.Setup(p => p.Message.Unit).Returns("Unit");
consumeContextMock.Setup(p => p.Message.Price).Returns(1111);
//Arrange Model object
var model = new ItemPriceAndCurrencyResponse();
model.Groups = new List <Groups>();
model.Groups.Add(new Groups
{
Id = consumeContextMock.Object.Message.ArticleGroup ?? default(int)
});
var desiredResult = new Item
{
Id = consumeContextMock.Object.Message.ItemNo,
Name = consumeContextMock.Object.Message.Name,
Price = consumeContextMock.Object.Message.Price
};
foreach (var group in model.Groups)
{
if (group.Id == 2222)
{
desiredResult.GroupId = group.Id;
desiredResult.Group = group;
}
}
//Act
var itemResult = creationOfItemEntityConsumer.
MapFromContext_ExistingFromResponse(consumeContextMock.Object, model);
//Assert
Assert.AreEqual(itemResult.Group, desiredResult.Group);
Assert.AreEqual(itemResult.GroupId, desiredResult.GroupId);
Assert.AreEqual(itemResult.Group, desiredResult.Group);
Assert.AreEqual(itemResult.Group, desiredResult.Group);
Assert.AreEqual(itemResult.Group, desiredResult.Group);
Assert.AreEqual(itemResult.Group, desiredResult.Group);
}
public void SetUp()
{
context = new Mock <ConsumeContext <IItemEntityUpdated> >();
_logger = new Mock <ILogger>();
context.Setup(p => p.Message.Unit).Returns("Unit");
context.Setup(p => p.Message.ArticleGroup).Returns(222);
context.Setup(p => p.Message.Name).Returns("Name");
context.Setup(p => p.Message.Price).Returns(111);
context.Setup(p => p.Message.ItemNo).Returns("ItemNo");
this.DesiredModel = new ItemPriceAndCurrencyResponse {
Currency = "Unit"
};
DesiredGroup = new Groups
{
Id = context.Object.Message.ArticleGroup ?? default
};
DesiredModel.Groups = new List <Groups>();
DesiredModel.Groups.Add(DesiredGroup);
DesiredGroup.Item = new List <Item>();
DesiredItem = new Item
{
Id = context.Object.Message.ItemNo,
Name = context.Object.Message.Name,
Price = context.Object.Message.Price
};
this.mapperMock = new Mock <IMapper>().Object;
this.serviceContextMock = new Mock <PriceCalendarServiceContext>().Object;
this.ArgumentModel = new ItemPriceAndCurrencyResponse();
this.ArgumentGroup = new Groups();
ArgumentGroup.Id = context.Object.Message.ArticleGroup ?? default;
this.ArgumentItem = new Item();
ArgumentItem.Id = context.Object.Message.ItemNo;
ArgumentModel.Groups = new List <Groups>();
ArgumentModel.Groups.Add(ArgumentGroup);
ArgumentGroup.Item = new List <Item>();
ArgumentGroup.Item.Add(ArgumentItem);
}
public Item MapFromContext_ExistingFromResponse(ConsumeContext <IItemEntityCreated> from, ItemPriceAndCurrencyResponse existing)
{
var item = new Item();
item.Id = from.Message.ItemNo;
item.Name = from.Message.Name;
item.Price = from.Message.Price;
item.GroupId = from.Message.ArticleGroup;
foreach (var group in existing.Groups)
{
if (group.Id == item.GroupId)
{
item.Group = group;
}
}
return(item);
}
public Groups MapFromContext_ExistingFromGroups(ConsumeContext <IItemEntityCreated> from, ItemPriceAndCurrencyResponse existing)
{
var group = new Groups
{
Id = from.Message.ArticleGroup ?? default(int),
Currency = existing,
CurrencyId = existing.Id,
Item = new List <Item>(),
Description = from.Message.PriceModel
};
var item = new Item
{
Group = group,
GroupId = group.Id,
Id = from.Message.ItemNo,
Name = from.Message.Name,
Price = from.Message.Price
};
group.Item.Add(item);
return(group);
}
