public async Task HandleAsync_WithValidData_ShouldStoreItem()
{
// Arrange
var local = new LocalFixture();
var handler = local.CreateCommandHandler();
IStoreItem storeItem = local.StoreItemFixture.CreateValid();
IStoreItemAvailability availability = local.CommonFixture.ChooseRandom(storeItem.Availabilities);
var command = local.CreateCommand(availability);
local.StoreItemFactoryMock.SetupCreate(command.TemporaryItemCreation, storeItem);
// Act
var result = await handler.HandleAsync(command, default);
// Assert
using (new AssertionScope())
{
result.Should().BeTrue();
local.AvailabilityValidationServiceMock.VerifyValidateOnce(
command.TemporaryItemCreation.Availability.ToMonoList());
local.ItemRepositoryMock.VerifyStoreAsyncOnce(storeItem);
}
}
public CreateTemporaryItemCommand CreateCommand(IStoreItemAvailability availability)
{
var fixture = CommonFixture.GetNewFixture();
fixture.ConstructorArgumentFor <TemporaryItemCreation, IStoreItemAvailability>("availability", availability);
return(fixture.Create <CreateTemporaryItemCommand>());
}
public void SetupCreate(StoreId storeId, float price, SectionId sectionId,
IStoreItemAvailability returnValue)
{
mock.Setup(i => i.Create(
It.Is <StoreId>(id => id == storeId),
It.Is <float>(p => p == price),
It.Is <SectionId>(id => id == sectionId)))
.Returns(returnValue);
}
private void ValidateItemIsAvailableAtStore(IStoreItem storeItem, StoreId storeId,
out IStoreItemAvailability availability)
{
availability = storeItem.Availabilities.FirstOrDefault(av => av.StoreId == storeId);
if (availability == null)
{
throw new DomainException(new ItemAtStoreNotAvailableReason(storeItem.Id, storeId));
}
}
private AvailableAt ToAvailableAt(IStoreItemAvailability availability, IStoreItem source)
{
return(new AvailableAt()
{
StoreId = availability.StoreId.Value,
Price = availability.Price,
ItemId = source.Id?.Value ?? 0,
DefaultSectionId = availability.DefaultSectionId.Value
});
}
public TemporaryItemCreation(Guid clientSideId, string name, IStoreItemAvailability availability)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException($"'{nameof(name)}' cannot be null or whitespace", nameof(name));
}
ClientSideId = clientSideId;
Name = name;
Availability = availability ?? throw new ArgumentNullException(nameof(availability));
}
public async Task <IEnumerable <ItemSearchReadModel> > ConvertAsync(IEnumerable <IStoreItem> items,
IStore store, CancellationToken cancellationToken)
{
var itemCategoryIds = items
.Where(i => i.ItemCategoryId != null)
.Select(i => i.ItemCategoryId)
.Distinct();
var itemCategoryDict = (await itemCategoryRepository.FindByAsync(itemCategoryIds, cancellationToken))
.ToDictionary(i => i.Id);
var manufacturerIds = items
.Where(i => i.ManufacturerId != null)
.Select(i => i.ManufacturerId)
.Distinct();
var manufaturerDict = (await manufacturerRepository.FindByAsync(manufacturerIds, cancellationToken))
.ToDictionary(m => m.Id);
return(items
.Select(item =>
{
IManufacturer manufacturer = item.ManufacturerId == null ? null : manufaturerDict[item.ManufacturerId];
IItemCategory itemCategory = item.ItemCategoryId == null ? null : itemCategoryDict[item.ItemCategoryId];
IStoreItemAvailability storeAvailability = item.Availabilities
.Single(av => av.StoreId == store.Id);
var section = store.Sections.Single(s => s.Id == storeAvailability.DefaultSectionId);
return new ItemSearchReadModel(
item.Id,
item.Name,
item.QuantityType.GetAttribute <DefaultQuantityAttribute>().DefaultQuantity,
storeAvailability.Price,
manufacturer?.ToReadModel(),
itemCategory?.ToReadModel(),
section.ToReadModel());
}));
}
public static StoreItemAvailabilityReadModel ToReadModel(this IStoreItemAvailability model, IStore store,
IStoreSection section)
{
return(new StoreItemAvailabilityReadModel(store.ToStoreItemStoreReadModel(), model.Price,
section.ToReadModel()));
}
