public void AddItem(string productId)
{
BasketItem newItem = new BasketItem(productId);
if (Items.Contains(newItem)) {
foreach (BasketItem item in Items) {
if (item.Equals(newItem)) {
item.Quantity++;
return;
}
}
} else {
newItem.Quantity = 1;
Items.Add(newItem);
}
}
public void SetItemQuantity(string productId, int quantity)
{
if (quantity == 0)
{
RemoveItem(productId);
return;
}
BasketItem updatedItem = new BasketItem(productId);
foreach (BasketItem item in Items)
{
if (item.Equals(updatedItem))
{
item.Quantity = quantity;
return;
}
}
}
public void Should_be_able_to_add_a_basket_item()
{
InSession(session =>
{
var size = session.Get<Size>(sizeId);
var basketItem = new BasketItem
{
Size = size,
Quantity = 1
};
var basket = session.Get<Basket>(basketId);
basket.AddBasketItem(basketItem);
});
// check basket was added
InSession(session =>
{
var basket = session.Get<Basket>(basketId);
basket.BasketItems.Count.ShouldEqual(1);
});
// delete basket item
InSession(session =>
{
var basket = session.Get<Basket>(basketId);
var basketItem = basket.BasketItems[0];
basket.BasketItems.Remove(basketItem);
});
// check basket item has been deleted
InSession(session =>
{
var basket = session.Get<Basket>(basketId);
basket.BasketItems.Count.ShouldEqual(0);
});
}
public async Task AddItemToBasket(int basketId, int productId, int quantity)
{
if (quantity < 1)
{
throw new ArgumentException("Quantity can not be zero or negative number");
}
var spec = new BasketItemSpecification(basketId, productId);
var basketItem = await _basketItemRepository.FirstOrDefaultAsync(spec);
if (basketItem != null)
{
basketItem.Quantity += quantity;
await _basketItemRepository.UpdateAsync(basketItem);
}
else
{
basketItem = new BasketItem()
{
BasketId = basketId, ProductId = productId, Quantity = quantity
};
await _basketItemRepository.AddAsync(basketItem);
}
}
public async Task Minus(BasketItem item)
{
item = BasketVC;
var options = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
};
var content = await LocalStorage.GetItemAsStringAsync("Basket");
var deserializedBasket = JsonSerializer.Deserialize <List <BasketItem> >(content, options);
if (BasketItems.Any(p => p.Product.Id == item.Product.Id))
{
if (BasketItems.FirstOrDefault(p => p.Product.Id == item.Product.Id).Count > 0)
{
BasketItems.FirstOrDefault(p => p.Product.Id == item.Product.Id).Count--;
}
}
var serializedBasket = JsonSerializer.Serialize <List <BasketItem> >(BasketItems);
await LocalStorage.SetItemAsync("Basket", serializedBasket);
}
public void AddToBasket(HttpContextBase httpContext, string productId)
{
Basket basket = GetBasket(httpContext, true);
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId);
if (item == null)
{
item = new BasketItem()
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity += 1;
}
basketContext.Commit();
}
public void AddToBasket(HttpContextBase httpContext, string productId)
{
Basket basket = GetBasket(httpContext, true);
//check if there is already a basket item in the user's basket with the same productid
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId);
if (item == null)
{
item = new BasketItem()
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity++;
}
basketContext.Commit();
}
public async Task <SaveBasketResponse> Save(Guid sessionId, BasketItem item)
{
var policy = _pollyPolicyProvider.BasketStorePolicy();
var result = await policy.ExecuteAndCaptureAsync(async() =>
{
await _basketStore.SaveOrUpdate(new BasketItemModel
{
ProductId = Guid.Parse(item.ProductId),
Quantity = item.Quantity,
SessionId = sessionId
});
});
if (result.Outcome == OutcomeType.Failure)
{
//LOG
var response = new SaveBasketResponse();
response.AddError(result.FinalException.Message);
return(response);
}
return(new SaveBasketResponse());
}
public IHttpActionResult AddItem([FromBody] AddItemModel model)
{
var basketId = model.BasketId;
if (model.BasketId == Guid.Empty)
{
basketId = Guid.NewGuid();
var cmd = Command.Create;
var envelope = createCommand(AggregateId.NewAggregateId(basketId), AggregateVersion.NewExpected(0), null, null, null, cmd);
CommitCommand(envelope);
}
// TODO: get model price and name from api by id
var productId = model.ProductId;
var item = new BasketItem(ProductId.NewProductId(productId), model.Name, model.Price, model.Quantity);
var addCmd = Command.NewAddItem(item);
var addEnvelope = createCommand(AggregateId.NewAggregateId(basketId), AggregateVersion.Irrelevant, null, null, null, addCmd);
var basket = CommitCommand(addEnvelope);
return(Ok(basket));
}
public async Task AddItemToBasket(int basketId, int productId, int quantity)
{
if (quantity < 1)
{
throw new ArgumentException("Quantity can not be 0 or negative number.");//miktar 1 den küçükse hata fırlat
}
var spec = new BasketItemSpecification(basketId, productId);
var basketItem = await _basketItemRepository.FirstOrDefaultAsync(spec);
if (basketItem != null)
{
basketItem.Quantity += quantity;// varsa miktarını bir arttır.
await _basketItemRepository.UpdateAsync(basketItem);
}
else
{
basketItem = new BasketItem()
{
BasketId = basketId, ProductId = productId, Quantity = quantity
}; //yoksa yeni bi ürün getir.
await _basketItemRepository.AddAsync(basketItem);
}
}
public async Task <IActionResult> UpdateItemBasket(Guid productId, BasketItem item)
{
var basket = await GetBasketCustomerAsync();
var basketItem = GetBasketItem(productId, basket, item);
if (basketItem == null)
{
return(CustomResponse());
}
basket.UpdateQuantity(basketItem, item.Qty);
ValidateBasket(basket);
if (!ValidOperation())
{
return(CustomResponse());
}
await _repository.Save(basket);
return(CustomResponse());
}
protected void btnAddBasket_Click(object sender, EventArgs e)
{
ShoppingBasket basket = ShoppingBasket.GetBasket();
BasketItem item = basket[hdnID.Value];
if (item == null)
{
Product product = new Product
{
ID = int.Parse(hdnID.Value),
Title = hdnTitle.Value,
Description = hdnDescription.Value,
Price = decimal.Parse(hdnPrice.Value),
ImagePath = hdnImage.Value
};
basket.AddItem(product, 1);
}
else
{
item.AddQuantity(1);
}
Response.Redirect("Basket.aspx");
}
public async Task BasketItemsGetAllReturnsOkAndItems()
{
var basket = new ShoppingBasket("1");
var postResponse = await PostBasketAsync(basket);
var postResult = postResponse.Content.ReadAsStringAsync().Result;
var item = new BasketItem(Guid.NewGuid().ToString(), "Product Name", 1.99M, 1);
var postResponse2 = await PostBasketItemAsync(basket, item);
var item2 = new BasketItem(Guid.NewGuid().ToString(), "Product Name2", 2.99M, 2);
var postResponse3 = await PostBasketItemAsync(basket, item2);
var response = await GetAsync(basket.CustomerId);
var result = response.Content.ReadAsStringAsync().Result;
var resultModel = JsonConvert.DeserializeObject <List <BasketItem> >(result);
response.EnsureSuccessStatusCode();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(resultModel.Exists(x => x.ProductId == item.ProductId));
Assert.IsTrue(resultModel.Exists(x => x.ProductId == item2.ProductId));
}
public void AddToBasket(HttpContextBase ctx, string productId)
{
Basket b = this.getBasket(ctx, true);
BasketItem item = b.Items.FirstOrDefault((it) => it.ProductID == productId);
if (item == null)
{
item = new BasketItem()
{
BasketID = b.ID,
ProductID = productId,
Quantity = 1,
};
b.Items.Add(item);
}
else
{
item.Quantity += 1;
}
this.baskets.Commit();
}
public bool AddToBasket(HttpContextBase httpContext, int productId, int quantity)
{
bool success = true;
Basket basket = GetBasket(httpContext);
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductID == productId);
if (item == null)
{
item = new BasketItem()
{
BasketID = basket.BasketID,
ProductID = productId,
Quantity = quantity
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity = item.Quantity + quantity;
}
baskets.Commit();
return(success);
}
/// <summary>
/// Adds the passed product into the basket with the specified ID.
/// If the basket with tha ID is null a new basket it will be automatically created before adding the item
/// </summary>
/// <param name="basketItem">The basket item.</param>
/// <param name="basketId">The basket identifier.</param>
public void AddProduct(BasketItem basketItem, int basketId)
{
var basket = Baskets.FirstOrDefault(i => i.BasketId == basketId);
if (basket == null)
{
CreateNewBasket(basketId);
}
basketItem.BasketId = basketId;
BasketItem existingItem = BasketProducts.FirstOrDefault(i => i.ProductId == basketItem.ProductId && i.BasketId == basketId);
if (existingItem == null)
{
BasketProducts.Add(basketItem);
}
else
{
existingItem.Quantity += basketItem.Quantity;
}
UpdateBasketProperty(basketItem, basketId);
UpdateProductStockQuantity(basketItem, null);
SaveChanges();
}
public void BasketTotalAmount_Given4BasketItem_BaksetTotalAmountShouldBe120()
{
//Arrange
var expected = 120;
IPriceEngine priceEngine = new PriceEngine();
ICheckout checkout = new Checkout(priceEngine);
var basket = new Basket();
var itemA = new BasketItem("A");
var itemB = new BasketItem("B");
var itemC = new BasketItem("C");
var itemD = new BasketItem("D");
basket.Add(itemA);
basket.Add(itemB);
basket.Add(itemC);
basket.Add(itemD);
//Act
var total = checkout.BasketTotalAmount(basket.basketItems);
//Assert
Assert.That(total, Is.EqualTo(expected));
}
static void Main(string[] args)
{
var consoleWriter = new ConsoleWriter();
var basketRepository = new BasketRepository();
var summaryPrinter = new SummaryPrinter(consoleWriter);
var basket = new Basket(basketRepository, summaryPrinter);
var item = new BasketItem(ProductData.Butter, 2);
var item2 = new BasketItem(ProductData.Bread, 1);
var item3 = new BasketItem(ProductData.Milk, 8);
basket.AddItem(item);
basket.AddItem(item2);
basket.AddItem(item3);
Console.WriteLine();
Console.WriteLine("\t\tBasket summary with applied discount(s)");
Console.WriteLine();
basket.PrintSummary();
Console.ReadLine();
}
/// <summary>
/// Modifies the quantity of the passed basket item.
/// </summary>
/// <param name="id">The identifier of the item you want to modify.</param>
/// <param name="basketItem">The new basket item.</param>
/// <returns>ProductInjuryResult.</returns>
public ProductInjuryResult ModifyCartItem(int id, BasketItem basketItem)
{
BasketItem existingItem = BasketProducts.FirstOrDefault(i => i.Id == id);
if (existingItem == null)
{
return(ProductInjuryResult.NotFound);
}
var newQuantity = basketItem.Quantity - existingItem.Quantity;
if (newQuantity > 0)
{
var result = CheckProduct(basketItem.ProductId, newQuantity);
if (result != ProductInjuryResult.Ok)
{
return(result);
}
}
existingItem.Quantity = basketItem.Quantity;
UpdateProductStockQuantity(basketItem, newQuantity);
SaveChanges();
return(ProductInjuryResult.Ok);
}
public BasketItem EditBasketItem(int basketItemId, int amount)
{
BasketItem itemToEdit = basketItemRepository.FindById(basketItemId);
int coffeeId = itemToEdit.Coffee.Id;
if (amount > model1.Coffees.Find(coffeeId).Storage)
{
return(itemToEdit);
}
else
{
decimal oldTotalPrice = itemToEdit.TotalPrice;
itemToEdit.Amount = amount;
decimal addPrice = amount * model1.Coffees.FirstOrDefault(m => m.Id == coffeeId).Price;
itemToEdit.TotalPrice = addPrice;
model1.BasketItems.FirstOrDefault(m => m.Id == basketItemId).Amount = amount;
model1.BasketItems.Find(basketItemId).TotalPrice = addPrice;
model1.Baskets.FirstOrDefault(m => m.Id == itemToEdit.Basket.Id).SumPrice -= oldTotalPrice;
model1.Baskets.FirstOrDefault(m => m.Id == itemToEdit.Basket.Id).SumPrice += addPrice;
model1.SaveChanges();
return(itemToEdit);
}
}
public static decimal GetInvoiceExtendedPrice(BasketItem item)
{
if (item.OrderItemType == OrderItemType.Discount)
{
return(0);
}
if (item.Product == null || !item.Product.VolumeDiscounts.Any() || !item.Product.VolumeDiscounts[0].Levels.Any())
{
return(Math.Abs(item.Price * item.Quantity));
}
VolumeDiscount volumeDiscount = item.Product.VolumeDiscounts[0];
if (volumeDiscount.Levels.Count < 1)
{
return(item.Price * item.Quantity);
}
decimal lastMinValue = volumeDiscount.Levels.Last().MinValue;
decimal discountAmount = 0;
foreach (var rec in volumeDiscount.Levels)
{
if (item.Quantity >= rec.MinValue && item.Quantity <= rec.MaxValue)
{
discountAmount = rec.DiscountAmount;
break;
}
else if (item.Quantity >= lastMinValue)
{
discountAmount = rec.DiscountAmount;
break;
}
}
return(discountAmount * item.Quantity);
}
public async Task AddItem_success()
{
//arrange
var customerId = "123";
var basket = GetCustomerBasketFake(customerId);
BasketItem input = new BasketItem("004", "004", "produto 004", 45.67m, 4);
var items = basket.Items;
items.Add(input);
_basketRepositoryMock
.Setup(c => c.AddBasketAsync(customerId, It.IsAny <BasketItem>()))
.ReturnsAsync(new CustomerBasket
{
CustomerId = customerId,
Items = items
})
.Verifiable();
var controller = new BasketController(
_basketRepositoryMock.Object,
_identityServiceMock.Object,
_serviceBusMock.Object,
_loggerMock.Object,
_configurationMock.Object);
//act
ActionResult <CustomerBasket> actionResult = await controller.AddItem(customerId, input);
//assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
CustomerBasket customerBasket = Assert.IsAssignableFrom <CustomerBasket>(okObjectResult.Value);
Assert.Equal(4, customerBasket.Items.Count());
_basketRepositoryMock.Verify();
_identityServiceMock.Verify();
_serviceBusMock.Verify();
}
private static bool DisplayBasketItem(BasketItem item, bool includeShipping)
{
// DO NOT INCLUDE ITEMS THAT ARE NOT OF A DISPLAYABLE TYPES
if (includeShipping)
{
if (Array.IndexOf(_displayItemTypesWithShipping, item.OrderItemType) < 0)
{
return(false);
}
}
else
{
if (Array.IndexOf(_displayItemTypes, item.OrderItemType) < 0)
{
return(false);
}
}
// ALWAYS SHOW ROOT ITEMS AND NON PRODUCT ITEMS
if (!item.IsChildItem || item.OrderItemType != OrderItemType.Product)
{
return(true);
}
// ONLY PRODUCT CHILD ITEMS REACH HERE
BasketItem parentItem = item.GetParentItem(true);
// IF THE PARENT ITEM IS ITEMIZED, CHILD PRODUCTS ARE VISIBLE
if (parentItem != null && parentItem.Product != null && parentItem.Product.Kit != null && parentItem.Product.Kit.ItemizeDisplay)
{
return(true);
}
else
{
return(false);
}
}
public async Task Index_BrokenCircuitException()
{
//arrange
var customerId = "cliente_id";
var products = GetFakeProducts();
var testProduct = products[0];
catalogServiceMock
.Setup(c => c.GetProduct(It.IsAny <string>()))
.ThrowsAsync(new BrokenCircuitException())
.Verifiable();
var itemBasket = new BasketItem(testProduct.Code, testProduct.Code, testProduct.Name, testProduct.Price, 1, testProduct.ImageURL);
basketServiceMock
.Setup(c => c.AddItem(customerId, It.IsAny <BasketItem>()))
.ReturnsAsync(
new CustomerBasket(customerId,
new List <BasketItem>
{
itemBasket
}))
.Verifiable();
var controller = GetBasketController();
SetControllerUser(customerId, controller);
//act
var result = await controller.Index(testProduct.Code);
////assert
//var viewResult = Assert.IsType<ViewResult>(result);
//loggerMock.Verify(l => l.Log(LogLevel.Error, It.IsAny<EventId>(), It.IsAny<FormattedLogValues>(), It.IsAny<Exception>(), It.IsAny<Func<object, Exception, string>>()), Times.Once);
//Assert.True(!string.IsNullOrWhiteSpace(controller.ViewBag.MsgServiceUnavailable as string));
//catalogServiceMock.Verify();
}
public async Task Index_Success()
{
//arrange
var customerId = "cliente_id";
var products = GetFakeProducts();
var testProduct = products[0];
catalogServiceMock
.Setup(c => c.GetProduct(testProduct.Code))
.ReturnsAsync(testProduct)
.Verifiable();
var itemBasket = new BasketItem(testProduct.Code, testProduct.Code, testProduct.Name, testProduct.Price, 1, testProduct.ImageURL);
basketServiceMock
.Setup(c => c.AddItem(customerId, It.IsAny <BasketItem>()))
.ReturnsAsync(
new CustomerBasket(customerId,
new List <BasketItem>
{
itemBasket
}))
.Verifiable();
var controller = GetBasketController();
SetControllerUser(customerId, controller);
//act
var result = await controller.Index(testProduct.Code);
//assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <CustomerBasket>(viewResult.Model);
Assert.Equal(model.Items[0].ProductName, products[0].Name);
catalogServiceMock.Verify();
}
public static void CollectProductTemplateInput(BasketItem item, Control container)
{
// COLLECT ANY ADDITIONAL INPUTS
Product product = item.Product;
if (product != null)
{
foreach (ProductTemplate template in product.ProductTemplates)
{
foreach (InputField input in template.InputFields)
{
//ONLY LOOK FOR CUSTOMER INPUT FIELDS
if (!input.IsMerchantField)
{
//SEE IF WE CAN LOCATE THE CONTROL
WebControl inputControl = (WebControl)AbleCommerce.Code.PageHelper.RecursiveFindControl(container, input.UniqueId);
if (inputControl != null)
{
// look for existing input item
BasketItemInput itemInput = item.Inputs.FirstOrDefault(bi => bi.InputFieldId == input.Id);
if (itemInput == null)
{
// need to add the input item
itemInput = new BasketItemInput();
itemInput.InputFieldId = input.Id;
itemInput.BasketItem = item;
item.Inputs.Add(itemInput);
}
// update input value
itemInput.InputValue = input.GetControlValue(inputControl);
}
}
}
}
}
}
public async Task <IActionResult> Index(string code = null)
{
string customerId = userManager.GetUserId(this.User);
CustomerBasket basket;
if (!string.IsNullOrWhiteSpace(code))
{
var product = await productRepository.GetProductAsync(code);
if (product == null)
{
return(RedirectToAction("ProductNotFound", "Basket", code));
}
var item = new BasketItem(product.Code, product.Code, product.Name, product.Price, 1);
basket = await basketRepository.AddBasketAsync(customerId, item);
}
else
{
basket = await basketRepository.GetBasketAsync(customerId);
}
return(View(basket));
}
//method for adding the item onto basket
public void AddToBasket(HttpContextBase httpContext, string productId)
{
Basket basket = GetBasket(httpContext, true);
//we always want the basket to be created first to add items onto basket so bool part is always true
//checking to see if there is already an item in the basketitem in the user's basket with this product id
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId);
if (item == null) //does that item exist in the basket
{
item = new BasketItem() //if it doesnt then we want to create a new item
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);//adding onto the basket
}
else//if item already exist in the basket then just increament the count
{
item.Quantity = item.Quantity + 1;
}
basketContext.Commit();//commiting all the changes we've made
}
public void AddToBasket(HttpContextBase httpContext, string productId)
{
// create if null
Basket basket = GetBasket(httpContext, true);
// Is this looking in db or in memory?
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId);
// does item exist in basket
if (item == null)
{
item = new BasketItem()
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity++;
}
basketContext.Commit();
}
public void RemoveFromBasket(HttpContextBase httpContext, string itemId)
{
Basket basket = GetBasket(httpContext, true);
if (basket != null)
{
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.Id == itemId);
if (item != null)
{
if (item.Quantity > 1)
{
item.Quantity--;
}
else
{
basketItemContext.Delete(itemId);
//basketContext.BasketItems.Remove(item);
basketItemContext.Commit();
}
}
basketContext.Commit();
}
}
public void AddToBasket(HttpContextBase httpContext, string productId)
{
Basket basket = GetBasket(httpContext, true); //insert the item
BasketItem item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId); //entity frmwrk loads all the basket items
//if item already in basket
if (item == null)
{
item = new BasketItem()
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity = item.Quantity + 1;
}
basketContext.Commit();//update collection
}
public async Task AddToBasket_ReturnsLaptopConfigurationList()
{
// Arrange
await using var context = new LaptopShopContext(_options);
await context.Basket.AddRangeAsync(MockDataProvider.GetBasketItems());
await context.SaveChangesAsync();
// Act
var item = new BasketItem
{
LaptopId = 2,
LaptopConfigurationIdList = new List <int> {
1, 4, 5
}
};
var result = await new LaptopRepository(context).AddToBasket(item);
// Assert
Assert.NotNull(result);
Assert.IsType <Basket[]>(result);
Assert.Equal(6, result.Length);
Assert.Equal(2, result.Select(r => r.LaptopId).Distinct().Count());
}
public void AddBasketItem_SingleItem_ItemIsAdded()
{
// Arrange
var item = new BasketItem {
Name = "Butter", Cost = 0.80M, Quantity = 1
};
var basket = new Basket();
var expected = new List <BasketItem>
{
item
};
// Act
basket.AddBasketItem(item);
var result = basket.BasketItems;
// Assert
Assert.AreEqual(expected.Count, result.Count, "Number of actual elements do not match the expected number of elements");
Assert.IsTrue(expected.All(e => result.Count(a => a.Name == e.Name) == 1) &&
expected.All(e => result.Count(a => a.Cost == e.Cost) == 1) &&
expected.All(e => result.Count(a => a.Quantity == e.Quantity) == 1), "Actual items do not match expected items");
}
public void Remove_ShouldRemoveItemFromBasket()
{
const int basketItemIdToRemove = 3;
var basketItem = new BasketItem
{
BasketItemId = basketItemIdToRemove,
Quantity = 1,
Size = new Size
{
Product = new Product {Weight = 100}
}
};
user.Baskets[0].BasketItems.Add(basketItem);
testContext.TestContext.Context.User = user;
basketController.Remove(basketItemIdToRemove)
.ReturnsRedirectToRouteResult()
.ToAction("Index");
basketItemRepository.AssertWasCalled(ir => ir.DeleteOnSubmit(basketItem));
}
public void Remove_ShouldRemoveItemFromBasket()
{
const int basketItemIdToRemove = 3;
var basketItem = new BasketItem
{
Id = basketItemIdToRemove,
Quantity = 1,
Size = new Size
{
Product = new Product {Weight = 100}
}
};
user.Baskets[0].BasketItems.Add(basketItem);
testContext.TestContext.Context.User = user;
basketController.Remove(basketItemIdToRemove)
.ReturnsRedirectToRouteResult()
.ToAction("Index");
user.Baskets[0].BasketItems.Count.ShouldEqual(0);
}
public void Calculates_linetotal_with_multiple_items() {
var item = new BasketItem(2, "foo", 5, 2);
item.LineTotal.ShouldEqual(20);
}
public void RemoveItem(string productId)
{
BasketItem removedItem = new BasketItem(productId);
Items.Remove(removedItem);
}
public void Calculates_vat() {
var item = new BasketItem(1, "foo", /*item price*/ 5, /*vat multiplier*/ 2);
item.ItemTax.ShouldEqual(5);
item.ItemTotal.ShouldEqual(10);
}
public override void AddItem(int itemId)
{
var item = new BasketItem { Id = itemId };
_basket.Items.Add(item);
_basket.State = BasketState.ContainsStuff;
}
public void Given()
{
_basketItem = new BasketItem(null, new Basket.Basket(), new NonNegativeQuantity(1));
}
