public async Task AddItemToCart_NotExistingItem_Failure()
{
using (var tester = new ShoppingCartTester())
{
// Assert
var cart = new Cart()
{
Id = "d3ab2dfa878227b15f1a0575",
Items = new List <Item>()
};
var notExistingItemId = "00002dfa878227b15f1a0000";
await tester.CartRepository.Add(cart);
var addModel = new AddItemToCartRequest()
{
CartId = cart.Id,
ItemId = notExistingItemId,
Amount = 3
};
// Act
var(result, message) = await tester.CartService.AddItemToCart(addModel);
// Assert
var resultItems = tester.CartRepository.GetAll().Result.ToList();
Assert.Empty(resultItems.First().Items);
Assert.Null(result);
Assert.NotNull(message);
}
}
public async Task AddItemToCart(int customerId, AddItemToCartRequest request, CancellationToken cancellationToken)
{
var customer = await _dbContext.Customers
.Include(c => c.Cart)
.SingleOrDefaultAsync(c => c.CustomerId == customerId);
customer.Cart.AddCartItem(request.ProductId, request.Quantity, request.Price);
await _dbContext.SaveChangesAsync(cancellationToken);
}
public ActionResult AddItem(AddItemToCartRequest request)
{
var cart = carts.GetCart(request.CartId);
var item = items.GetItem(request.ItemId);
cart.AddItem(item);
carts.Save(cart);
// Redirect to action showing the "item added" or whatever.
}
public async Task AddItemToCart_ItemAdded_ReturnsSuccess()
{
// we need a customer and product with ID 1.
var customerId = 1;
var request = new AddItemToCartRequest
{
Price = 19.99m,
Quantity = 2,
ProductId = 1,
CustomerId = 1
};
var resp = await PostAsync($"api/customers/{customerId}/cart", request);
Assert.That(resp.IsSuccessStatusCode);
}
public async Task <ActionResult <Cart> > AddItemToCart(AddItemToCartRequest request)
{
var validationError = CheckRequestValidationErrors(request);
if (validationError != null)
{
return(BadRequest(validationError));
}
var(cart, error) = await cartService.AddItemToCart(request);
if (error != null)
{
return(BadRequest(error));
}
return(Ok(cart));
}
private string CheckRequestValidationErrors(AddItemToCartRequest request)
{
if (request.CartId == null || request.CartId.Length != 24)
{
return("Cart id not valid");
}
if (request.ItemId == null || request.ItemId.Length != 24)
{
return("Item id not valid");
}
if (request.Amount < 1)
{
return("Amount should greater than zero");
}
return(null);
}
public Either <Error, Unit> Handle(AddItemToCartRequest input)
{
var maybeCart = _cartRepository.Get(input.CartId);
if (!maybeCart.TryGetValue(out var cart))
{
return(Either.Left <Error, Unit>(new Error.NotFound("Couldn't find the cart")));
}
var item = _itemRepository.Get(input.ItemId);
if (item is null)
{
return(Either.Left <Error, Unit>(new Error.NotFound("Couldn't find the item")));
}
var rules = _itemSaleRuleRepository.GetForItem(item.Id);
var rulesResult = rules.Validate(cart, item, input.Quantity);
if (rulesResult is Either <Error, Unit> .Left)
{
return(rulesResult);
}
var cartItemResult = cart.AddItemToCart(item, input.Quantity);
if (cartItemResult is Either <Error, CartItem> .Left cartItemErrorResult)
{
return(Either.Left <Error, Unit>(cartItemErrorResult.Value));
}
_cartRepository.Save(cart);
_listener.OnAdded(cart, item, ((Either <Error, CartItem> .Right)cartItemResult).Value);
return(Either.Right <Error, Unit>(Unit.Instance));
}
public async Task AddItemToCart_NotExistingCart_Failure()
{
using (var tester = new ShoppingCartTester())
{
// Assert
var cartId = "16a70cb62d6a2ff9bfffe180";
var item1 = new Item()
{
Name = "Rose",
Description = "Red",
Quantity = 10,
Price = 5
};
await tester.ItemRepository.Add(item1);
tester.StockCache.SetStock(item1.Id, item1.Quantity);
var addModel = new AddItemToCartRequest()
{
CartId = cartId,
ItemId = item1.Id,
Amount = 3
};
// Act
var(result, message) = await tester.CartService.AddItemToCart(addModel);
// Assert
var cartFromDb = tester.CartRepository.Find(cartId).Result;
Assert.Null(result);
Assert.NotNull(message);
Assert.Null(cartFromDb);
}
}
public Either <Error, Unit> Handle(AddItemToCartRequest input)
{
var maybeCart = _cartRepository.Get(input.CartId);
if (!maybeCart.TryGetValue(out var cart))
{
return(Either.Left <Error, Unit>(new Error.NotFound("Couldn't find the cart")));
}
var item = _itemRepository.Get(input.ItemId);
if (item is null)
{
return(Either.Left <Error, Unit>(new Error.NotFound("Couldn't find the item")));
}
var rules = _itemSaleRuleRepository.GetForItem(item.Id);
return(rules
.Validate(cart, item, input.Quantity)
.FlatMap(_ => cart.AddItemToCart(item, input.Quantity))
.Do(_ => _cartRepository.Save(cart))
.Do(cartItem => _listener.OnAdded(cart, item, cartItem))
.Map(_ => Unit.Instance));
}
public IHttpActionResult AddItemToCart([FromBody] AddItemToCartRequest request)
{
return(this.Ok(this.cartService.AddItemToActiveCart(request.UserId, request.ProductId, request.Quantity)));
}
public async Task <IActionResult> AddToCart(int customerId, [FromBody] AddItemToCartRequest cartItem, CancellationToken cancellationToken)
{
await _customerService.AddItemToCart(customerId, cartItem, cancellationToken);
return(Ok());
}
public AddItemToCartResponse AddItemToCart(AddItemToCartRequest addItemToCartRequest)
{
AddItemToCartResponse response = new AddItemToCartResponse();
var cart = GetCart();
if (cart != null)
{
var existingCartItem = _cartItemRepository.FindCartItemsByCartId(cart.Id)
.FirstOrDefault(c => c.ProductId == addItemToCartRequest.ProductId);
if (existingCartItem != null)
{
existingCartItem.Quantity++;
_cartItemRepository.UpdateCartItem(existingCartItem);
response.CartItem = _messageMapper.MapToCartItemDto(existingCartItem);
}
else
{
var product = _productRepository.FindProductById(addItemToCartRequest.ProductId);
if (product != null)
{
var cartItem = new CartItem
{
CartId = cart.Id,
Cart = cart,
ProductId = addItemToCartRequest.ProductId,
Product = product,
Quantity = 1
};
_cartItemRepository.SaveCartItem(cartItem);
response.CartItem = _messageMapper.MapToCartItemDto(cartItem);
}
}
}
else
{
var product = _productRepository.FindProductById(addItemToCartRequest.ProductId);
if (product != null)
{
var newCart = new Cart
{
UniqueCartId = UniqueCartId(),
CartStatus = CartStatus.Open
};
_cartRepository.SaveCart(newCart);
var cartItem = new CartItem
{
CartId = newCart.Id,
Cart = newCart,
ProductId = addItemToCartRequest.ProductId,
Product = product,
Quantity = 1
};
_cartItemRepository.SaveCartItem(cartItem);
response.CartItem = _messageMapper.MapToCartItemDto(cartItem);
}
}
return(response);
}
public ActionResult <AddItemToCartResponse> AddItemToCart(AddItemToCartRequest addItemToCartRequest)
{
var addItemToCartResponse = _cartService.AddItemToCart(addItemToCartRequest);
return(addItemToCartResponse);
}
public async Task AddItemToCart_EmptyCart_ExistingItem_SufficientQuantity_Success()
{
using (var tester = new ShoppingCartTester())
{
// Assert
var cartId = "16a70cb62d6a2ff9bfffe180";
var cart = new Cart()
{
Id = cartId,
Items = new List <Item>()
};
var item1 = new Item()
{
Name = "Rose",
Description = "Red",
Quantity = 10,
Price = 5
};
var item2 = new Item()
{
Name = "Daisy",
Description = "White",
Quantity = 3,
Price = 2
};
await tester.CartRepository.Add(cart);
await tester.ItemRepository.Add(item1);
await tester.ItemRepository.Add(item2);
tester.StockCache.SetStock(item1.Id, item1.Quantity);
tester.StockCache.SetStock(item2.Id, item2.Quantity);
var addModel = new AddItemToCartRequest()
{
CartId = cart.Id,
ItemId = item1.Id,
Amount = 3
};
// Act
var(result, message) = await tester.CartService.AddItemToCart(addModel);
// Assert
var cartFromDb = tester.CartRepository.Find(cartId).Result;
var remainingStock = tester.StockCache.GetStock(item1.Id);
Assert.NotNull(result);
Assert.Null(message);
Assert.NotNull(cartFromDb);
Assert.Equal(cart.Id, cartFromDb.Id);
Assert.Single(cartFromDb.Items);
Assert.Equal(item1.Id, cartFromDb.Items.First().Id);
Assert.Equal(3, cartFromDb.Items.First().Quantity);
Assert.Equal(7, remainingStock);
}
}
public ActionResult <AddItemToCartResponse> AddItemToCart(AddItemToCartRequest request)
{
var response = _service.AddItemToCart(request);
return(response);
}
public void Post([FromBody] AddItemToCartRequest request)
{
}
