internal async Task AddItemToShoppingList(IShoppingList shoppingList, IShoppingListItem item,
SectionId sectionId, CancellationToken cancellationToken)
{
var store = await storeRepository.FindByAsync(shoppingList.StoreId, cancellationToken);
if (store == null)
{
throw new DomainException(new StoreNotFoundReason(shoppingList.StoreId));
}
if (!store.ContainsSection(sectionId))
{
throw new DomainException(new SectionInStoreNotFoundReason(sectionId, store.Id));
}
cancellationToken.ThrowIfCancellationRequested();
if (!shoppingList.Sections.Any(s => s.Id == sectionId))
{
var section = shoppingListSectionFactory.CreateEmpty(sectionId);
shoppingList.AddSection(section);
}
shoppingList.AddItem(item, sectionId);
}
public async Task ExchangeItemAsync(ItemId oldItemId, IStoreItem newItem, CancellationToken cancellationToken)
{
if (oldItemId is null)
{
throw new System.ArgumentNullException(nameof(oldItemId));
}
if (newItem is null)
{
throw new System.ArgumentNullException(nameof(newItem));
}
var shoppingListsWithOldItem = (await shoppingListRepository
.FindActiveByAsync(oldItemId, cancellationToken))
.ToList();
foreach (var list in shoppingListsWithOldItem)
{
IShoppingListItem oldListItem = list.Items
.First(i => i.Id == oldItemId);
list.RemoveItem(oldListItem.Id);
if (newItem.IsAvailableInStore(list.StoreId))
{
var sectionId = newItem.GetDefaultSectionIdForStore(list.StoreId);
await addItemToShoppingListService.AddItemToShoppingList(list, newItem.Id, sectionId,
oldListItem.Quantity, cancellationToken);
if (oldListItem.IsInBasket)
{
list.PutItemInBasket(newItem.Id);
}
}
await shoppingListRepository.StoreAsync(list, cancellationToken);
}
}
public async Task ExchangeItemAsync_WithNewItemAvailableForShoppingListAndNotInBasket_ShouldRemoveOldItemAndAddNewItem()
{
// Arrange
var local = new LocalFixture();
var service = local.CreateService();
ShoppingListMock shoppingListMock = local.CreateShoppingListMockNotInBasket();
var shopppingListStoreId = shoppingListMock.Object.StoreId;
IShoppingListItem oldShoppingListItem = shoppingListMock.GetRandomItem(local.CommonFixture, i => !i.IsInBasket);
ItemId oldItemId = oldShoppingListItem.Id;
IStoreItem newItem = local.CreateNewItemForStore(shopppingListStoreId);
local.ShoppingListRepositoryMock.SetupFindActiveByAsync(oldItemId, shoppingListMock.Object.ToMonoList());
// Act
await service.ExchangeItemAsync(oldItemId, newItem, default);
// Assert
var sectionId = newItem.Availabilities.First(av => av.StoreId == shopppingListStoreId).DefaultSectionId;
using (new AssertionScope())
{
shoppingListMock.VerifyRemoveItemOnce(oldItemId);
local.ShoppingListRepositoryMock.VerifyStoreAsyncOnce(shoppingListMock.Object);
local.AddItemToShoppingListServiceMock.VerifyAddItemToShoppingListOnce(shoppingListMock.Object,
newItem.Id, sectionId, oldShoppingListItem.Quantity);
shoppingListMock.VerifyPutItemInBasketNever();
}
}
public void RemoveFromBasket_WithValidItemId_ShouldRemoveItemFromList()
{
// Arrange
var sectionMocks = shoppingListSectionMockFixture.CreateMany(3).ToList();
var listDefinition = new ShoppingListDefinition()
{
Sections = sectionMocks.Select(s => s.Object)
};
var shoppingList = shoppingListFixture.Create(listDefinition);
ShoppingListSectionMock chosenSectionMock = commonFixture.ChooseRandom(sectionMocks);
IShoppingListItem chosenItem = commonFixture.ChooseRandom(chosenSectionMock.Object.Items);
sectionMocks.ForEach(m => m.SetupContainsItem(m == chosenSectionMock));
// Act
shoppingList.RemoveFromBasket(chosenItem.Id);
// Assert
using (new AssertionScope())
{
foreach (var section in sectionMocks)
{
if (section == chosenSectionMock)
{
section.VerifyRemoveItemFromBasketOnce(chosenItem.Id);
}
else
{
section.VerifyRemoveItemFromBasketNever();
}
}
}
}
public void AddItem(IShoppingListItem item, SectionId sectionId)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
if (sectionId == null)
{
throw new ArgumentNullException(nameof(sectionId));
}
if (Items.Any(it => it.Id == item.Id))
{
throw new DomainException(new ItemAlreadyOnShoppingListReason(item.Id, Id));
}
if (!sections.ContainsKey(sectionId))
{
throw new DomainException(new SectionNotPartOfStoreReason(sectionId, StoreId));
}
var section = sections[sectionId];
sections[sectionId] = section.AddItem(item);
}
public IShoppingListSection CreateValidWithItem(IShoppingListItem item)
{
var def = new ShoppingListSectionDefinition
{
Items = item.ToMonoList()
};
return(CreateValid(def));
}
public void SetupCreate(ItemId itemId, bool isInBasket, float quantity,
IShoppingListItem returnValue)
{
mock
.Setup(instance => instance.Create(
It.Is <ItemId>(id => id == itemId),
It.Is <bool>(b => b == isInBasket),
It.Is <float>(q => q == quantity)))
.Returns(returnValue);
}
public IShoppingListSection AddItem(IShoppingListItem item)
{
var items = new Dictionary <ItemId, IShoppingListItem>(shoppingListItems);
if (items.ContainsKey(item.Id))
{
throw new DomainException(new ItemAlreadyInSectionReason(item.Id, Id));
}
items.Add(item.Id, item);
return(new ShoppingListSection(Id, items.Values));
}
internal async Task AddItemToShoppingList(IShoppingList shoppingList, IStoreItem storeItem,
SectionId sectionId, float quantity, CancellationToken cancellationToken)
{
ValidateItemIsAvailableAtStore(storeItem, shoppingList.StoreId, out var availability);
if (sectionId == null)
{
sectionId = availability.DefaultSectionId;
}
cancellationToken.ThrowIfCancellationRequested();
IShoppingListItem shoppingListItem = CreateShoppingListItem(storeItem.Id, quantity);
await AddItemToShoppingList(shoppingList, shoppingListItem, sectionId, cancellationToken);
}
public void AddItem_WithSectionNotFound_ShouldThrowDomainException()
{
IShoppingList shoppingList = shoppingListFixture.CreateValid();
IShoppingListItem item = shoppingListItemFixture.CreateUnique(shoppingList);
var existingSectionIds = shoppingList.Sections.Select(s => s.Id.Value);
int sectionId = commonFixture.NextInt(exclude: existingSectionIds);
// Act
Action action = () => shoppingList.AddItem(item, new SectionId(sectionId));
// Assert
using (new AssertionScope())
{
action.Should().Throw <DomainException>()
.Where(e => e.Reason.ErrorCode == ErrorReasonCode.SectionInStoreNotFound);
}
}
public void AddItem_WithValidItemWithActualId_ShouldAddItemToList()
{
// Arrange
var sections = shoppingListSectionMockFixture.CreateMany(3).ToList();
var listDefinition = new ShoppingListDefinition()
{
Sections = sections.Select(s => s.Object)
};
var shoppingList = shoppingListFixture.Create(listDefinition);
ShoppingListSectionMock chosenSection = commonFixture.ChooseRandom(sections);
IShoppingListItem item = shoppingListItemFixture.CreateUnique(shoppingList);
// Act
shoppingList.AddItem(item, chosenSection.Object.Id);
// Assert
using (new AssertionScope())
{
chosenSection.VerifyAddItemOnce(item);
}
}
public void ChangeItemQuantity_WithValidItemId_ShouldChangeQuantity()
{
// Arrange
var sectionMocks = shoppingListSectionMockFixture.CreateMany(3).ToList();
var listDefinition = new ShoppingListDefinition()
{
Sections = sectionMocks.Select(s => s.Object)
};
var shoppingList = shoppingListFixture.Create(listDefinition);
ShoppingListSectionMock chosenSectionMock = commonFixture.ChooseRandom(sectionMocks);
IShoppingListItem chosenItem = commonFixture.ChooseRandom(chosenSectionMock.Object.Items);
sectionMocks.ForEach(m => m.SetupContainsItem(m == chosenSectionMock));
float quantity = commonFixture.NextFloat();
// Act
shoppingList.ChangeItemQuantity(chosenItem.Id, quantity);
// Assert
using (new AssertionScope())
{
foreach (var section in sectionMocks)
{
if (section == chosenSectionMock)
{
section.VerifyChangeItemQuantityOnce(chosenItem.Id, quantity);
}
else
{
section.VerifyChangeItemQuantityNever();
}
}
}
}
public void VerifyAddItemOnce(IShoppingListItem item)
{
Verify(i => i.AddItem(
It.Is <IShoppingListItem>(itm => itm == item)),
Times.Once);
}
public void VerifyAddItemOnce(IShoppingListItem listItem, SectionId sectionId)
{
Verify(i => i.AddItem(listItem, sectionId),
Times.Once);
}
// Delete item
private Task <IOption <UserMessage> > Remove(IShoppingListItem item) =>
ShoppingListHandler
.Remove(CurrentAccount, foodstuffs.Get(item.FoodstuffId).Get().ToEnumerable())
.Map(result => ProcessResult(result))
.Execute(environment);
