public void Add_IsNull_ExceptionThrown()
{
var sut = new ShoppingBasketService(_productService.Object);
// Assert
Assert.Throws <NullReferenceException>(() => sut.AddProducts(null));
}
public void GetBasket_1_bread_1_butter_1_milk()
{
userBasketRepo.Setup(b => b.Get(It.IsAny <Func <IUserBasketItem, bool> >()))
.Returns(() =>
{
return(new List <IBasketItem>
{
new BasketItem()
{
Id = 1, Name = "Butter", Price = 0.8
},
new BasketItem()
{
Id = 2, Name = "Milk", Price = 1.15
},
new BasketItem()
{
Id = 3, Name = "Bread", Price = 1.0
},
});
});
SetupDiscounts();
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
var basket = service.GetUserBasket(USER_ID);
PrintBasketToConsole(basket);
Assert.IsTrue(basket.DiscountPrice == 2.95);
Assert.IsTrue(basket.TotalPrice == 2.95);
}
public void RandomProductFor_PercentageDiscount_CalculateAppliedDiscount_With10PercentDiscount(List <Product> products, PercentageDiscount percentageDiscount)
{
var discountRate = 0.10m;
// Arrange
percentageDiscount._percentage = discountRate;
var productNames = products.Select(x => x.Name).ToList();
productNames.Add(percentageDiscount._discountedProduct.Name);
var disconts = new List <IDiscount>();
disconts.Add(percentageDiscount);
_productService.Setup(x => x.GetProductByName(percentageDiscount._discountedProduct.Name)).Returns(percentageDiscount._discountedProduct);
foreach (var item in products)
{
_productService.Setup(x => x.GetProductByName(item.Name)).Returns(item);
}
var sut = new ShoppingBasketService(_productService.Object);
var basket = sut.AddProducts(productNames.ToArray());
var sutD = new DiscountService();
// Act
var result = sutD.CalculateBasketDiscounts(basket, disconts);
var subTotalPrice = basket.Sum(item => item.Product.Price * item.Quantity);
var totalPrice = subTotalPrice - result.Sum(item => item.Amount);
var discontMessage = string.Join(" --- ", result.Select(x => x.Description));
// Assert
Assert.Equal(subTotalPrice - totalPrice, percentageDiscount._discountedProduct.Price * percentageDiscount._percentage);
}
public void AddItems()
{
userBasketRepo.Setup(x => x.AddRange(It.IsAny <List <IUserBasketItem> >()))
.Returns(() =>
{
return(new List <IUserBasketItem>
{
new UserBasketItem
{
ItemId = 1,
UserId = USER_ID
}
});
});
basketItemRepo.Setup(x => x.Exists(It.IsAny <Func <IBasketItem, bool> >()))
.Returns(true);
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
var newItem = new AddItemModel(1, 1);
var hasAddedItem = service.Add(newItem, USER_ID);
Assert.IsTrue(hasAddedItem);
}
public void ReturnShoppingBasket()
{
//Arrange
const string expectedUserCart = "- 12/03/2019/n" +
"- 2 x The Hobbit // 2 x 5.00 = �.00" +
"- 5 x Breaking Bad // 5 x 7.00 = �.00" +
"- Total: �.00";
var shoppingBasketRepository = new ShoppingBasketRepository();
var shoppingBasketService = new ShoppingBasketService(shoppingBasketRepository);
const string breakingBadProductId = "20110";
const string hobbitProductId = "10002";
//Act
const string userId = "1";
shoppingBasketService.AddItem(userId, hobbitProductId, 2);
shoppingBasketService.AddItem(userId, breakingBadProductId, 5);
var userCart = shoppingBasketService.BasketFor(userId);
//Assert
Assert.Equal(expectedUserCart, userCart);
}
public void GetProductTaxRate_GivenProductIsNotExemptAndIsImported_ExpectingMaximumTaxRate()
{
//arrage
var order = new Order()
{
TaxRules = new TaxRules()
{
BasicRate = 0.15M,
ExemptProductTypes = new List <string> {
"book", "food", "medical"
},
ImportRate = 0.05M
}
};
var product = new Product
{
IsImported = true,
Type = "transport"
};
//act
var sb = new ShoppingBasketService();
var result = sb.SetOrder(order).GetProductTaxRate(product);
//assert
Assert.AreEqual(0.20M, result);
}
public void DoesntThrowException_WhenParameterIsNotNull()
{
// Act
ShoppingBasketService sut = new ShoppingBasketService(shoppingBasketDtoMock.Object, mapperServiceMock.Object, efDbSetWrapper.Object, efDbContextSaveChanges.Object);
// Assert
Assert.IsNotNull(sut);
}
public void CreateDependenciesOfTests()
{
this.shoppingBasketDto = new ShoppingBasketDto();
this.mapperService = new MapperService();
this.efDbContext = new EfDbContext();
this.efDbSetWrapper = new EfDbSetWrapper <ShoppingBasket>(efDbContext);
this.shoppingBasketService = new ShoppingBasketService(shoppingBasketDto, mapperService, efDbSetWrapper, efDbContext);
}
public void DeleteThrowsShoppingBasketException()
{
userBasketRepo.Setup(b => b.GetItem(It.IsAny <Func <IUserBasketItem, bool> >()))
.Returns((UserBasketItem)null);
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
Assert.Throws <ShoppingBasketException>(delegate { service.Delete(1, USER_ID); });
}
public DiscountApplicationSteps()
{
this.shoppingBasketDto = new ShoppingBasketDto();
this.mapperService = new MapperService();
this.efDbContext = new EfDbContext();
this.efDbSetWrapper = new EfDbSetWrapper <ShoppingBasket>(efDbContext);
this.shoppingBasketService = new ShoppingBasketService(shoppingBasketDto, mapperService, efDbSetWrapper, efDbContext);
}
public void Setup()
{
var taxRateRetreiver = new TaxRateRetriever();
var taxesCalculator = new TaxesCalculator(taxRateRetreiver);
var basketItemManager = new BasketItemManager(taxesCalculator);
var receiptBuilder = new ReceiptBuilder();
shoppingBasketService = new ShoppingBasketService(receiptBuilder, basketItemManager);
}
static void Main(string[] args)
{
var productSystem = new PretendPurchaseSystem();
var lordOfTheRings = new ProductId(10001);
var theHobbit = new ProductId(10002);
var gameOfThrones = new ProductId(20001);
var breakingBad = new ProductId(20110);
var inventory = new Inventory(productSystem);
inventory.Add(lordOfTheRings, 10, 10m);
inventory.Add(theHobbit, 12, 5m);
inventory.Add(gameOfThrones, 8, 9m);
inventory.Add(breakingBad, 14, 7m);
inventory.Print(Console.Out);
var john = new UserId("john");
var kim = new UserId("kim");
var basketRepository = new InMemoryBasketRepository();
var basketFactory = new BasketFactory(new SystemClock(),
Console.Out,
inventory);
var shoppingBasketService = new ShoppingBasketService(
basketRepository,
basketFactory,
inventory);
// No discounts
shoppingBasketService.AddItem(john, lordOfTheRings, 1);
shoppingBasketService.AddItem(john, theHobbit, 1);
shoppingBasketService.AddItem(kim, breakingBad, 1);
var johnsCart = shoppingBasketService.BasketFor(john);
var kimsCart = shoppingBasketService.BasketFor(kim);
Console.WriteLine($"John's basket total: {johnsCart.Total:c}");
Console.WriteLine($"Kim's basket total: {kimsCart.Total:c}");
var johnsPayment = new PaymentDetails();
var orderService = new OrderService(new OrderIdGenerator(), basketRepository);
var paymentGateway = new PretendPaymentGateway();
var orderConfirmation = new PretendOrderConfirmation();
var paymentService = new PaymentService(orderService,
paymentGateway,
inventory,
orderConfirmation);
paymentService.MakePayment(john, johnsCart.Id, johnsPayment);
inventory.Print(Console.Out);
}
static void Main(string[] args)
{
var validationEngine = new ValidationService();
var discountService = new DiscountService();
var promotionRepository = new PromotionRepository();
var itemPriceCalculator = new ItemPriceCalculatorService(promotionRepository, validationEngine, discountService);
// Add Promotions
promotionRepository.AddPromotion(new Promotion {
PromotionId = 1, Description = "'X' for 'N' Promotion", PromotionPrice = 40.00M, QuantityTrigger = 3, PromotionPercentageReduction = 0.00M
});
promotionRepository.AddPromotion(new Promotion {
PromotionId = 2, Description = "'X'% off for every 'N' purchased together Promotion", PromotionPrice = 40.00M, QuantityTrigger = 2, PromotionPercentageReduction = 25.00M
});
// Prep. Items
var testItem1 = new Item {
SkuId = "A", PromotionId = 0, Description = "Test Widget 1", UnitPrice = 10.00M
};
var testItem2 = new Item {
SkuId = "B", PromotionId = 1, Description = "Test Widget 2", UnitPrice = 15.00M
};
var testItem3 = new Item {
SkuId = "C", PromotionId = 0, Description = "Test Widget 3", UnitPrice = 40.00M
};
var testItem4 = new Item {
SkuId = "D", PromotionId = 2, Description = "Test Widget 4", UnitPrice = 55.00M
};
var shoppingBasket = new ShoppingBasketService(itemPriceCalculator, validationEngine);
// Add Sample Items to Basket
var cartGrandTotal = 0.00M;
// A
shoppingBasket.TryAddItemToBasket(testItem1, 8, out var cartSubTotal1);
cartGrandTotal = cartSubTotal1;
// B
shoppingBasket.TryAddItemToBasket(testItem2, 7, out var cartSubTotal2);
cartGrandTotal = cartSubTotal2;
// C
shoppingBasket.TryAddItemToBasket(testItem3, 5, out var cartSubTotal3);
cartGrandTotal = cartSubTotal3;
// D
shoppingBasket.TryAddItemToBasket(testItem4, 3, out var cartSubTotal4);
cartGrandTotal = cartSubTotal4;
Console.WriteLine($"Total Cost of Basket: £{cartGrandTotal}");
Console.WriteLine("Press any key to exit the application..");
Console.ReadKey(false);
}
public void AddItemsThrowsShoppingBasketException()
{
basketItemRepo.Setup(b => b.Exists(It.IsAny <Func <IBasketItem, bool> >()))
.Returns(false);
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
var newItem = new AddItemModel(1, 1);
Assert.Throws <ShoppingBasketException>(delegate { service.Add(newItem, USER_ID); });
}
public void GetProductByName_Is_Null_ExceptionThrown(Product product, string exeptedProductName)
{
// Arrange
var productName = product.Name;
var productNames = new string[] { exeptedProductName };
_productService.Setup(x => x.GetProductByName(productName)).Returns(product);
var sut = new ShoppingBasketService(_productService.Object);
// Assert
Assert.Throws <NotSupportedException>(() => sut.AddProducts(productNames));
}
public void ApplyTwoInOneAndOneEuroless_WhenThereAreTwoOrMuchVouchersAndThreeOrMoreTshirts()
{
this.shoppingBasketDtoMock.Setup(s => s.Products).Returns(TestsServices.CreateListWithThreeVouchersAndThreeTshirts());
ShoppingBasketService sut = new ShoppingBasketService(shoppingBasketDtoMock.Object, mapperServiceMock.Object, efDbSetWrapper.Object, efDbContextSaveChanges.Object);
//act
var result = sut.GetTotalPrice() - sut.ApplyDiscountVoucher() - sut.ApplyDiscountTshirt();
//assert
Assert.AreEqual(74.5, result);
}
public void NotApplyOneEuroLess_WhenThereAreLessOfThreeTshirts()
{
//arrange
shoppingBasketDtoMock.Setup(s => s.Products).Returns(TestsServices.CreateListWithTwoTshirts());
ShoppingBasketService sut = new ShoppingBasketService(shoppingBasketDtoMock.Object, mapperServiceMock.Object, efDbSetWrapper.Object, efDbContextSaveChanges.Object);
//act
var result = sut.GetTotalPrice() - sut.ApplyDiscountVoucher() - sut.ApplyDiscountTshirt();
//assert
Assert.AreEqual(57.5, result);
}
public void ReturnsTotalPriceOfTheProducts()
{
//arrange
shoppingBasketDtoMock.Setup(s => s.Products).Returns(TestsServices.CreateListWithThreeVouchersAndThreeTshirts());
ShoppingBasketService sut = new ShoppingBasketService(shoppingBasketDtoMock.Object, mapperServiceMock.Object, efDbSetWrapper.Object, efDbContextSaveChanges.Object);
//act
var result = sut.GetTotalPrice();
//assert
Assert.AreEqual(82.5, result);
}
public void Can_Add_One_Product(Product product)
{
// Arrange
var productName = product.Name;
var productNames = new string[] { productName };
_productService.Setup(x => x.GetProductByName(productName)).Returns(product);
var sut = new ShoppingBasketService(_productService.Object);
// Act
var result = sut.AddProducts(productNames);
// Assert
Assert.Equal(result.Count, 1);
}
public void CallsOnceTimeMethodOfAddOffDbSetWrapperAndOnceTimeSaveChanges()
{
// Arrange
ShoppingBasket shoppingBasket = new ShoppingBasket();
this.shoppingBasketDtoMock.Setup(x => x.Products).Returns(TestsServices.CreateListWithThreeVouchersAndThreeTshirts);
var sut = new ShoppingBasketService(this.shoppingBasketDtoMock.Object, this.mapperServiceMock.Object, this.efDbSetWrapper.Object, this.efDbContextSaveChanges.Object);
// Act
sut.AddShoppingBasket();
// Assert
this.efDbSetWrapper.Verify(x => x.Add(It.IsAny <ShoppingBasket>()), Times.Once);
this.efDbContextSaveChanges.Verify(x => x.SaveChanges(), Times.Once);
}
public void GetBasket_NoItems()
{
userBasketRepo.Setup(b => b.Get(It.IsAny <Func <IUserBasketItem, bool> >()))
.Returns(() => null);
SetupDiscounts();
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
var basket = service.GetUserBasket(USER_ID);
PrintBasketToConsole(basket);
Assert.IsTrue(basket.TotalPrice == 0);
Assert.IsTrue(basket.DiscountPrice == 0);
}
public void ReturnsZero_WhenNotProducts()
{
//arrange
shoppingBasketDtoMock.Setup(s => s.Products).Returns(
new List <ProductDto>()
{
});
ShoppingBasketService sut = new ShoppingBasketService(shoppingBasketDtoMock.Object, mapperServiceMock.Object, efDbSetWrapper.Object, efDbContextSaveChanges.Object);
//act
var result = sut.GetTotalPrice();
//assert
Assert.AreEqual(0, result);
}
public void SaveShoppingBasketOnBasketRepository()
{
var shoppingBasketRepository = Substitute.For <IShoppingBasketRepository>();
var shoppingBasketService = new ShoppingBasketService(shoppingBasketRepository);
const string userId = "1";
const string productId = "10002";
const int quantity = 2;
var item = new Item(productId, quantity);
var shoppingBasket = new ShoppingBasket(userId, item);
shoppingBasketService.AddItem(userId, productId, 2);
shoppingBasketRepository.Received().Save(shoppingBasket);
}
public void Add_Product_And_Check_Quantity(Product product)
{
// Arrange
var productName = product.Name;
var productNames = new string[] { productName, productName };
_productService.Setup(x => x.GetProductByName(productName)).Returns(product);
var sut = new ShoppingBasketService(_productService.Object);
// Act
var result = sut.AddProducts(productNames);
var productQuantity = result.SingleOrDefault(x => x.Product.Name == productName);
// Assert
Assert.Equal(productQuantity.Quantity, 2);
}
public void AddProducts_And_CheckProductsCount(List <Product> products)
{
// Arrange
var productNames = products.Select(x => x.Name).ToArray();
foreach (var item in products)
{
_productService.Setup(x => x.GetProductByName(item.Name)).Returns(item);
}
var sut = new ShoppingBasketService(_productService.Object);
// Act
var result = sut.AddProducts(productNames);
// Assert
Assert.Equal(result.Count, products.Count);
}
public void Checkout()
{
//Setup
var book = new Item()
{
Description = "book",
Price = 12.49m,
TypeOfItem = TypeOfItem.Book,
IsImported = false
};
var musicCd = new Item()
{
Description = "music cd",
Price = 14.99m,
TypeOfItem = TypeOfItem.Other,
IsImported = false
};
var chocolateBar = new Item()
{
Description = "chocolate bar",
Price = 0.85m,
TypeOfItem = TypeOfItem.Food,
IsImported = false
};
var items = new Item[] { book, musicCd, chocolateBar };
basketItemManager.Setup(m => m.AddToBasket(It.IsAny <Item>())).Returns(new PurchasedItem());
receiptBuilderMock.Setup(m => m.CreateReceipt(It.IsAny <PurchasedItem[]>())).Returns(new Receipt());
var shoppingBasketService = new ShoppingBasketService(receiptBuilderMock.Object, basketItemManager.Object);
//SUT Call
Receipt receipt = shoppingBasketService.Checkout(items);
//Assertion
basketItemManager.Verify(m => m.AddToBasket(It.IsAny <Item>()), Times.Exactly(3));
receiptBuilderMock.Verify(m => m.CreateReceipt(It.IsAny <PurchasedItem[]>()), Times.Exactly(1));
}
public ShoppingBasketServiceTests()
{
var purchaseSystemStub = new Mock <IPurchaseSystem>().Object;
this.inventory = new Inventory(purchaseSystemStub);
this.inventory.Add(lor, 5, 10m);
this.inventory.Add(hobbit, 5, 5m);
this.johnsBasket = new Basket(john,
DateTime.Parse("2020-05-11"),
this.inventory);
this.ryansBasket = new Basket(ryan,
DateTime.Parse("2012-02-12"),
this.inventory);
this.repoMock = new Mock <IBasketRepository>();
this.basketFactoryMock = new Mock <IBasketFactory>();
this.sut = new ShoppingBasketService(repoMock.Object,
basketFactoryMock.Object,
inventory);
}
public void CallsAllMethodsNecessaryToAddTheNewBasket()
{
// Arrange
IList <ShoppingBasket> baskets = new List <ShoppingBasket>();
ShoppingBasket shoppingBasket = new ShoppingBasket();
this.efDbSetWrapper.Setup(x => x.Add(It.IsAny <ShoppingBasket>())).Callback(() => this.efDbContext.Object.Set <ShoppingBasket>().Add(shoppingBasket));
this.efDbContext.Setup(x => x.Set <ShoppingBasket>().Add(shoppingBasket)).Callback(() => baskets.Add(shoppingBasket));
this.shoppingBasketDtoMock.Setup(x => x.Products).Returns(TestsServices.CreateListWithThreeVouchersAndThreeTshirts);
var shoppingBasketDtoMock = new Mock <IShoppingBasketDto>();
var sut = new ShoppingBasketService(this.shoppingBasketDtoMock.Object, this.mapperServiceMock.Object, this.efDbSetWrapper.Object, this.efDbContextSaveChanges.Object);
// Act
sut.AddShoppingBasket();
// Assert
Assert.IsTrue(baskets.Count > 0);
}
public void AddItemsThrowsArgumentNullException()
{
var service = new ShoppingBasketService(userBasketRepo.Object, basketItemRepo.Object, discountRepo.Object);
Assert.Throws <ArgumentNullException>(delegate { service.Add(null, USER_ID); });
}
