protected NewCartItem BuildNewCartItem(string productId, int quantity, decimal productPrice) { var catalogProductId = _fixture.Create <string>(); var catalogProduct = new CatalogProduct { Id = catalogProductId }; var cartProduct = new CartProduct(catalogProduct); cartProduct.ApplyPrices(new List <Price>() { new Price { ProductId = catalogProductId, PricelistId = _fixture.Create <string>(), List = _fixture.Create <decimal>(), MinQuantity = _fixture.Create <int>(), } }, GetCurrency()); var newCartItem = new NewCartItem(productId, quantity) { Price = productPrice, CartProduct = cartProduct }; return(newCartItem); }
public async Task <ActionResult <Cart> > CreateCart(NewCartItem newItem) { var cartItem = new CartItem { FlowerId = newItem.FlowerId }; var exists = await _context.Carts.AnyAsync(a => a.CartNumber == newItem.CartNumber); if (exists) { var cart = await _context.Carts.FirstOrDefaultAsync(f => f.CartNumber == newItem.CartNumber); cart.CartItems.Add(cartItem); var flower = await _context.Flowers.FirstOrDefaultAsync(f => f.Id == cartItem.FlowerId); flower.NumberInStock--; await _context.SaveChangesAsync(); return(cart); } else { var cart = new Cart(); cart.CartItems.Add(cartItem); var flower = await _context.Flowers.FirstOrDefaultAsync(f => f.Id == cartItem.FlowerId); flower.NumberInStock--; await _context.Carts.AddAsync(cart); await _context.SaveChangesAsync(); return(cart); } }
public void AddItemAsync_ShouldThrow_IfQuantityLessOrEqualZero(int quantity) { // Arrange var productId = _fixture.Create <string>(); var newCartItem = new NewCartItem(productId, quantity); var shoppingCart = _fixture.Create <ShoppingCart>(); shoppingCart.Items = Enumerable.Empty <LineItem>().ToList(); _cartProductServiceMock .Setup(x => x.GetCartProductsByIdsAsync(It.IsAny <CartAggregate>(), new[] { productId })) .ReturnsAsync(new List <CartProduct>() { new CartProduct(new CatalogProduct()) }); // Act var aggregateAfterAddItem = aggregate.AddItemAsync(newCartItem).GetAwaiter().GetResult(); // Assert aggregateAfterAddItem.ValidationErrors.Should().NotBeEmpty(); aggregateAfterAddItem.ValidationErrors.Should().Contain(x => x.ErrorCode == "GreaterThanValidator"); aggregateAfterAddItem.ValidationErrors.Should().Contain(x => x.ErrorCode == "NotNullValidator"); }
public CartItem AddCartItem(NewCartItem newItem, MailingList mailingList = null) { var addedAmount = newItem?.Quantity ?? 0; if (addedAmount < 1) { throw new ArgumentException(resources.GetResourceString("Kadena.Product.InsertedAmmountValueIsNotValid")); } var productDocument = DocumentHelper.GetDocument(newItem.DocumentId, new TreeProvider(MembershipContext.AuthenticatedUser)); var productType = productDocument.GetValue("ProductType", string.Empty); var isTemplatedType = ProductTypes.IsOfType(productType, ProductTypes.TemplatedProduct); var cartItem = ECommerceContext.CurrentShoppingCart.CartItems .FirstOrDefault(i => i.SKUID == productDocument.NodeSKUID && i.GetValue("ChilliEditorTemplateID", Guid.Empty) == newItem.TemplateId); var isNew = false; if (cartItem == null) { isNew = true; cartItem = isTemplatedType ? CreateCartItem(productDocument, newItem.TemplateId) : CreateCartItem(productDocument); } var existingAmountInCart = isNew ? 0 : cartItem.CartItemUnits; if (productType.Contains(ProductTypes.InventoryProduct)) { EnsureInventoryAmount(productDocument, addedAmount, existingAmountInCart); } var isMailingType = ProductTypes.IsOfType(productType, ProductTypes.MailingProduct); if (isTemplatedType || isMailingType) { if (isMailingType) { if (mailingList?.AddressCount != addedAmount) { throw new ArgumentException(resources.GetResourceString("Kadena.Product.InsertedAmmountValueIsNotValid")); } SetMailingList(cartItem, mailingList); } SetAmount(cartItem, addedAmount); } else { SetAmount(cartItem, addedAmount + existingAmountInCart); } SetArtwork(cartItem, productDocument.GetStringValue("ProductArtwork", string.Empty)); RefreshPrice(cartItem, productDocument); SetCustomName(cartItem, newItem.CustomProductName); ShoppingCartItemInfoProvider.SetShoppingCartItemInfo(cartItem); return(GetShoppingCartItems().FirstOrDefault(i => i.Id == cartItem.CartItemID)); }
public async Task AddItemsAsync_ItemsExist_ShouldAddNewItems() { // Arrange var productId1 = _fixture.Create <string>(); var newCartItem1 = new NewCartItem(productId1, 1); var productId2 = _fixture.Create <string>(); var newCartItem2 = new NewCartItem(productId2, 2); var newCartItems = new List <NewCartItem>() { newCartItem1, newCartItem2 }; _cartProductServiceMock .Setup(x => x.GetCartProductsByIdsAsync(It.IsAny <CartAggregate>(), new[] { productId1, productId2 })) .ReturnsAsync( new List <CartProduct>() { new CartProduct(new CatalogProduct() { Id = productId1, IsActive = true, IsBuyable = true }), new CartProduct(new CatalogProduct() { Id = productId2, IsActive = true, IsBuyable = true }), }); _mapperMock.Setup(m => m.Map <LineItem>(It.IsAny <object>())).Returns <object>((arg) => { if (arg is CartProduct cartProduct) { return(new LineItem() { ProductId = cartProduct.Id }); } return(null); }); var cartAggregate = GetValidCartAggregate(); cartAggregate.ValidationRuleSet = new string[] { "default" }; cartAggregate.Cart.Items = Enumerable.Empty <LineItem>().ToList(); // Act var newAggregate = await cartAggregate.AddItemsAsync(newCartItems); // Assert cartAggregate.Cart.Items.Should().Contain(x => x.ProductId == newCartItem1.ProductId); cartAggregate.Cart.Items.Should().Contain(x => x.ProductId == newCartItem2.ProductId); }
public async Task <BulkCartResult> Handle(AddCartItemsBulkCommand request, CancellationToken cancellationToken) { var result = new BulkCartResult(); var cartItemsToAdd = new List <NewCartItem>(); // find missing skus var products = await FindProductsBySkuAsync(request); foreach (var item in request.CartItems) { var product = products.FirstOrDefault(x => x.Code == item.ProductSku); if (product != null) { var newCartItem = new NewCartItem(product.Id, item.Quantity); cartItemsToAdd.Add(newCartItem); } else { var error = CartErrorDescriber.BulkInvalidProductError(nameof(CatalogProduct), item.ProductSku); result.Errors.Add(error); } } // send Add to Cart command var command = new AddCartItemsCommand { CartId = request.CartId, StoreId = request.StoreId, CartType = request.CartType, CartName = request.CartName, UserId = request.UserId, CurrencyCode = request.CurrencyCode, CultureName = request.CultureName, CartItems = cartItemsToAdd.ToArray(), }; var cartAggregate = await _mediator.Send(command, cancellationToken); result.Cart = cartAggregate; // transform cart product unavaliable validation erorrs to human readable var lineItemErrors = cartAggregate.ValidationErrors .OfType <CartValidationError>() .Where(x => x.ObjectType == "CartProduct" && x.ErrorCode == "CART_PRODUCT_UNAVAILABLE") .Select(x => { var sku = products.FirstOrDefault(p => p.Id == x.ObjectId)?.Code ?? x.ObjectId; var error = CartErrorDescriber.BulkProductUnavailableError(nameof(CatalogProduct), sku); return(error); }); result.Errors.AddRange(lineItemErrors); return(result); }
public void AddItemAsync_ShouldThrowArgumentNullException_IfNewCartItemIsNull() { // Arrange NewCartItem newCartItem = null; // Act Action action = () => aggregate.AddItemAsync(newCartItem).GetAwaiter().GetResult(); // Assert action.Should().ThrowExactly <ArgumentNullException>("NewCartItem is null"); }
private void MoqDefaultSetup(NewCartItem cartItem) { this.productApiConnectorMock .Setup(c => c.ProductExists(cartItem.ProductId)) .Returns(true); this.productApiConnectorMock .Setup(c => c.GetStock(cartItem.ProductId)) .Returns(cartItem.Quantity + 1); this.userApiMock .Setup(c => c.UserExists(cartItem.UserId)) .Returns(true); }
public async Task <IHttpActionResult> UpdateTemplate([FromBody] NewCartItem item) { var result = await _templateService.UpdateTemplate(item.TemplateId, item.CustomProductName, item.Quantity); if (result) { return(ResponseJson(result)); } else { return(ErrorJson("Failed request. See logs for more information.")); } }
public async Task Throws_Invalid_Product_Async() { var cartItem = new NewCartItem(1, 2, 10); this.MoqDefaultSetup(cartItem); this.productApiConnectorMock .Setup(c => c.ProductExists(cartItem.ProductId)) .Returns(false); var service = this.GetService(); var exc = await Assert.ThrowsAsync <CartException>( () => service.AddCartItemAsync(cartItem)); Assert.Equal(CartErrorCode.InvalidProduct, exc.ErrorCode); }
public async Task Adds_CartItem_To_DataStore_Async() { var cartItem = new NewCartItem(1, 2, 10); this.MoqDefaultSetup(cartItem); var service = this.GetService(); await service.AddCartItemAsync(cartItem); var userCart = await this.dataMock.GetUserCartAsync(cartItem.UserId); Assert.Equal(userCart.UserId, cartItem.UserId); Assert.Equal(1, userCart.Items.Count); Assert.Equal(userCart.Items[cartItem.ProductId].Quantity, cartItem.Quantity); }
public async Task Throws_InsufficientStock_Async() { var cartItem = new NewCartItem(1, 2, 10); this.MoqDefaultSetup(cartItem); this.productApiConnectorMock .Setup(c => c.GetStock(cartItem.ProductId)) .Returns(cartItem.Quantity - 1); var service = this.GetService(); var exc = await Assert.ThrowsAsync <CartException>( () => service.AddCartItemAsync(cartItem)); Assert.Equal(CartErrorCode.InsufficientStock, exc.ErrorCode); }
public async Task Throws_InvalidUser_Async() { var cartItem = new NewCartItem(1, 2, 10); this.MoqDefaultSetup(cartItem); this.userApiMock .Setup(c => c.UserExists(cartItem.UserId)) .Returns(false); var service = this.GetService(); var exc = await Assert.ThrowsAsync <CartException>( () => service.AddCartItemAsync(cartItem)); Assert.Equal(CartErrorCode.InvalidUser, exc.ErrorCode); }
public async Task ValidateAddItem_RuleSetDefault_Valid() { // Arrange var validator = new NewCartItemValidator(); var newCartItem = new NewCartItem(Rand.Guid().ToString(), Rand.Int(1, InStockQuantity)) { CartProduct = _fixture.Create <CartProduct>() }; // Act var result = await validator.ValidateAsync(newCartItem, ruleSet : "default"); // Assert result.IsValid.Should().BeTrue(); result.Errors.Should().BeEmpty(); }
public async Task <AddToCartResult> AddToCart(NewCartItem item) { var mailingList = await mailingService.GetMailingList(item.ContainerId); var addedItem = shoppingCart.AddCartItem(item, mailingList); var result = new AddToCartResult { CartPreview = ItemsPreview(), Confirmation = new RequestResult { AlertMessage = resources.GetResourceString("Kadena.Product.ItemsAddedToCart") } }; return(result); }
public async Task ValidateAddItem_RuleSetDefault_Invalid() { // Arrange var validator = new NewCartItemValidator(); var newCartItem = new NewCartItem(null, 0); // Act var result = await validator.ValidateAsync(newCartItem, ruleSet : "default"); // Assert result.IsValid.Should().BeFalse(); result.Errors.Should().NotBeEmpty(); result.Errors.Should().HaveCount(3); result.Errors.Should().Contain(x => x.PropertyName == "Quantity" && x.ErrorCode == nameof(GreaterThanValidator)); result.Errors.Should().Contain(x => x.PropertyName == "ProductId" && x.ErrorCode == nameof(NotNullValidator)); result.Errors.Should().Contain(x => x.PropertyName == "CartProduct" && x.ErrorCode == nameof(NotNullValidator)); }
public async Task Throws_InsufficientStock_Cumulative_Async() { var cartItem = new NewCartItem(1, 2, 2); var secondItem = new NewCartItem(cartItem.UserId, cartItem.ProductId, 3); int totalQuantity = cartItem.Quantity + secondItem.Quantity; this.MoqDefaultSetup(cartItem); this.productApiConnectorMock .Setup(c => c.GetStock(cartItem.ProductId)) .Returns(totalQuantity - 1); var service = this.GetService(); await service.AddCartItemAsync(cartItem); var exc = await Assert.ThrowsAsync <CartException>( () => service.AddCartItemAsync(secondItem)); Assert.Equal(CartErrorCode.InsufficientStock, exc.ErrorCode); var userCart = await this.dataMock.GetUserCartAsync(cartItem.UserId); Assert.Equal(userCart.Items[cartItem.ProductId].Quantity, cartItem.Quantity); }
public async Task Increments_Quantity_When_Product_Exists() { var cartItem = new NewCartItem(1, 2, 2); var secondItem = new NewCartItem(cartItem.UserId, cartItem.ProductId, 3); int totalQuantity = cartItem.Quantity + secondItem.Quantity; this.MoqDefaultSetup(cartItem); this.productApiConnectorMock .Setup(c => c.GetStock(cartItem.ProductId)) .Returns(totalQuantity + 1); var service = this.GetService(); await service.AddCartItemAsync(cartItem); var userCart = await this.dataMock.GetUserCartAsync(cartItem.UserId); Assert.Equal(userCart.Items[cartItem.ProductId].Quantity, cartItem.Quantity); await service.AddCartItemAsync(secondItem); userCart = await this.dataMock.GetUserCartAsync(cartItem.UserId); Assert.Equal(userCart.Items[cartItem.ProductId].Quantity, totalQuantity); }