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);