public void AddItemToCart_shoppingCartItemWIthSameIdInCartDifferentName_DoNotSaveReturnBadRequest()
{
const string productId = "item-1";
const double price = 1;
var cart = new CartBuilder()
.WithItems(new List <Item>
{
CreateItem(productId, "product name", price, 1)
})
.Build();
var fakeShoppingCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeShoppingCartRepository.Setup(x => x.FindById("cart-1")).Returns(cart);
var target = _mocker.CreateInstance <ShoppingCartController>();
var result = target.AddItemToCart("cart-1",
CreateItemDto(productId, "other name", price, 2));
Assert.IsType <BadRequestResult>(result.Result);
fakeShoppingCartRepository.Verify(x => x.Update("cart-1", It.IsAny <Cart>()), Times.Never());
}
public void AddItemToCart_shoppingCartItemWIthSameIdInCartSameDetails_IncreaseItemCount()
{
const string productId = "item-1";
const string productName = "name";
const double price = 1;
var cart = new CartBuilder()
.WithItems(new List <Item>
{
CreateItem(productId, productName, price, 2)
})
.Build();
var fakeShoppingCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeShoppingCartRepository.Setup(x => x.FindById("cart-1")).Returns(cart);
var target = _mocker.CreateInstance <ShoppingCartController>();
var result = target.AddItemToCart("cart-1",
CreateItemDto(productId, productName, price, 3));
Assert.IsType <OkResult>(result.Result);
fakeShoppingCartRepository.Verify(x =>
x.Update("cart-1", It.Is <Cart>(c => c.Items.Single().Quantity == 5)));
}
public void CalculateTotals_MoreThanOneItem_TotalEqualsCostPlusShipping()
{
var originAddress = CreateAddress(city: "city 1");
_mocker.Use <IShippingCalculator>(new ShippingCalculator(originAddress));
var destinationAddress = CreateAddress(city: "city 2");
var target = _mocker.CreateInstance <CheckOutEngine>();
var cart = new CartBuilder()
.WithShippingAddress(destinationAddress)
.WithShippingMethod(ShippingMethod.Standard)
.WithItems(new List <Item>
{
CreateItem(price: 2, quantity: 3),
CreateItem(price: 4, quantity: 5)
})
.Build();
var result = target.CalculateTotals(cart);
Assert.Equal(2 * 3 + 4 * 5 + result.ShippingCost, result.Total);
}
public void CalculateTotals_InvalidCouponExceptionThrown_ReturnBadRequest()
{
var coupon = CreateCoupon("coupon-1", CouponType.Amount, 100);
var fakeCouponRepository = _mocker.GetMock <ICouponRepository>();
fakeCouponRepository.Setup(x => x.FindById("coupon-1")).Returns(coupon);
var cart = new CartBuilder()
.WithId("cart-1")
.Build();
var fakeShoppingCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeShoppingCartRepository.Setup(x => x.FindById("cart-1"))
.Returns(cart); // I do not care about this result
var fakeCheckoutEngine = _mocker.GetMock <ICheckOutEngine>();
fakeCheckoutEngine
.Setup(x => x.CalculateTotals(It.IsAny <Cart>()))
.Returns(CreateCheckOutDto(total: 0));
_mocker.Use <IAddressValidator>(new AddressValidator());
_mocker.Use <ICouponEngine>(new CouponEngine()); // we need a REAL coupon engine
_mocker.Use <ICheckOutEngine>(_mocker.CreateInstance <CheckOutEngine>()); // we need a REAL checkout engine
_mocker.Use(_mocker.CreateInstance <ShoppingCartManager>());
var target = _mocker.CreateInstance <ShoppingCartController>();
var result =
target.CalculateTotals("cart-1", "coupon-1"); // cart id not use as fake cart repository was faked
Assert.IsType <BadRequestResult>(result.Result);
}
public void AddItemToCart_shoppingCartItemWithSameIdNotInCart_CreateNewItem()
{
var cart = new CartBuilder()
.WithId("cart-1")
.WithItems(new List <Item> {
CreateItem("other")
})
.Build();
string[] actualItemIds = null;
var fakeShoppingCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeShoppingCartRepository.Setup(x => x.FindById("cart-1")).Returns(cart);
fakeShoppingCartRepository.Setup(x => x.Update("cart-1", It.IsAny <Cart>()))
.Callback((string _, Cart c) =>
{
actualItemIds = c.Items.Select(i => i.ProductId).ToArray();
}); // this is a trick to extract complex objects and using assert instead of using verify (see below)
var target = _mocker.CreateInstance <ShoppingCartController>();
var result = target.AddItemToCart("cart-1", CreateItemDto("item-1"));
Assert.IsType <OkResult>(result.Result);
// This is a verify that only looks like an assertion
Assert.Equal(new[] { "other", "item-1" }, actualItemIds);
/* This is the alternative, the problem is that when this test fail it is hard to know why
*
* fakeShoppingCartRepository.Verify(x => x.Update("cart-1",
* It.Is((Cart c )=> c.Items.Select(i => i.ProductId).ToArray() == new[] { "other", "item-1" })));
*/
}
public static List <object[]> International()
{
Address address = Utility.AddressGenerate("Ukraine");
CartBuilder cartFactory = new CartBuilder();
return(cartFactory.GenerateInternational(address));
}
public void Update_CartNotFound_DoNotFail()
{
var target = new FakeShoppingCartRepository(_databaseSettings);
var cart1 = new CartBuilder().WithId(null).WithCustomerId("1").Build();
target.Update(Invalid_ID, cart1);
}
private ICartBuilder GetCartBuilder()
{
var catalogApi = GetCatalogApiClient();
var cartApi = GetCartApiClient();
var marketingApi = GetMarketingApiClient();
var inventoryApi = GetInventoryApiClient();
var pricingApi = GetPricingApiClient();
var searchApi = GetSearchApiClient();
var customerApi = GetCustomerApiClient();
var orderApi = GetOrderApiClient();
var quoteApi = GetQuoteApiClient();
var storeApi = GetStoreApiClient();
var cacheManager = new Mock <ILocalCacheManager>().Object;
var workContextFactory = new Func <WorkContext>(GetTestWorkContext);
var promotionEvaluator = new PromotionEvaluator(marketingApi);
var pricingService = new PricingServiceImpl(pricingApi, null, promotionEvaluator);
var customerService = new CustomerServiceImpl(workContextFactory, customerApi, orderApi, quoteApi, storeApi, null, cacheManager);
var catalogSearchService = new CatalogSearchServiceImpl(workContextFactory, catalogApi, inventoryApi, searchApi, pricingService, customerService, null);
var retVal = new CartBuilder(workContextFactory, cartApi, catalogSearchService, cacheManager, promotionEvaluator, null, null);
return(retVal);
}
public static List <object[]> SameCountry()
{
Address address = Utility.AddressGenerate("USA", "New York");
CartBuilder cartFactory = new CartBuilder();
return(cartFactory.GenerateSameCountry(address));
}
private ICartBuilder GetCartBuilder()
{
var catalogApi = GetCatalogApiClient();
var cartApi = GetCartApiClient();
var marketingApi = GetMarketingApiClient();
var inventoryApi = GetInventoryApiClient();
var pricingApi = GetPricingApiClient();
var customerApi = GetCustomerApiClient();
var orderApi = GetOrderApiClient();
var quoteApi = GetQuoteApiClient();
var storeApi = GetStoreApiClient();
var cacheManager = new Mock <ILocalCacheManager>().Object;
var workContextFactory = new Func <WorkContext>(GetTestWorkContext);
var promotionEvaluator = new PromotionEvaluator(marketingApi);
var inventoryService = new Mock <IInventoryService>().Object;
var pricingService = new PricingServiceImpl(pricingApi, GetTaxEvaluator(), promotionEvaluator, inventoryService);
var customerService = new CustomerServiceImpl(workContextFactory, customerApi, orderApi, quoteApi, storeApi, GetSubscriptionModuleApiClient(), cacheManager);
var catalogSearchService = new CatalogSearchServiceImpl(workContextFactory, catalogApi, inventoryApi, pricingService, customerService, GetSubscriptionModuleApiClient(), GetProductAvailabilityService(), inventoryService);
var retVal = new CartBuilder(workContextFactory, cartApi, catalogSearchService, cacheManager, promotionEvaluator, GetTaxEvaluator(), GetSubscriptionModuleApiClient(), GetProductAvailabilityService());
return(retVal);
}
public void AddToCartTest()
{
var product = new ProductBuilder().Constructer(ProductName, Desc, Quantity, Price);
var cart = new CartBuilder().Constructer(CartName);
cart = cart.AddToCart(product.Id, 1);
Assert.Single(cart.Build().CartItems);
Assert.IsType <CartItem>(cart.Build().CartItems.FirstOrDefault());
}
public CartBuilderTests()
{
this.fixture = this.CreateOmitOnRecursionFixture();
this.catalogService = Substitute.For <ICatalogService>();
this.cartMapper = Substitute.For <ICartMapper>();
this.cartBuilder = new CartBuilder(this.catalogService, this.cartMapper);
}
public CartBuilderTests()
{
this.fixture = new Fixture().Customize(new OmitOnRecursionCustomization());
this.catalogService = Substitute.For <ICatalogService>();
this.cartMapper = Substitute.For <ICartMapper>();
this.cartBuilder = new CartBuilder(this.catalogService, this.cartMapper);
}
public void FindCartItemFalseTest()
{
var product = new ProductBuilder().Constructer(ProductName, Desc, Quantity, Price);
var cart = new CartBuilder().Constructer(CartName);
cart = cart.AddToCart(product.Id, 1);
Assert.False(cart.FindCartItem(new Guid()));
}
public void RaiseCartCreatedEvent()
{
var item = new CartBuilder().Constructer(CartName);
item.Build().CreatedEvent();
Assert.Single(item.Build().Events);
Assert.IsType <CartCreated>(item.Build().Events.First());
}
public void CalculateTotals_NoShippingAddress_ThrowException()
{
_mocker.Use <IShippingCalculator>(new ShippingCalculator());
var target = _mocker.CreateInstance <CheckOutEngine>();
var cart = new CartBuilder()
.WithShippingAddress(null)
.Build();
Assert.Throws <MissingDataException>(() => target.CalculateTotals(cart));
}
public GetCartImplTests()
{
var currentUser = new User();
Session.Transact(session => session.Save(currentUser));
CurrentRequestData.CurrentUser = currentUser;
_getUserGuid = A.Fake <IGetUserGuid>();
_cartBuilder = new CartBuilder(A.Fake <IAssignBasicCartInfo>(), A.Fake <IAssignShippingInfo>(),
A.Fake <IAssignCartDiscountInfo>(), A.Fake <IAssignGiftCardInfo>(),
A.Fake <IAssignRewardPointInfo>(), A.Fake <IAssignPaymentInfo>(), _getUserGuid);
}
public void AddCartAndSetId()
{
var repository = GetRepository();
var item = new CartBuilder().Constructer(CartName).Build();
repository.Add(item);
var newItem = repository.List <Cart>().FirstOrDefault();
Assert.Equal(item, newItem);
Assert.True(newItem?.Id != null);
}
public void CalculateShippingCost_NoItems_Return0(Address source, Address destination)
{
var target = new ShippingCalculator(source);
var cart = new CartBuilder()
.WithShippingAddress(destination)
.Build();
var result = target.CalculateShippingCost(cart);
Assert.Equal(0, result);
}
public void Finds_A_New_Cart()
{
var cartBuilder = new CartBuilder();
var address = Builders.Utility.AddressGenerate();
var shoppingCartRepository = new ShoppingCartRepository(_shoppingCartDatabaseSettings);
var cart = cartBuilder.GenerateCart(address, CustomerType.Premium, ShippingMethod.Expedited);
var storedCart = shoppingCartRepository.Create(cart);
var result = shoppingCartRepository.FindById(storedCart.Id);
result.Should().BeEquivalentTo(cart);
}
public void RemoveCartItemFalseTest()
{
var product = new ProductBuilder().Constructer(ProductName, Desc, Quantity, Price);
var cart = new CartBuilder().Constructer(CartName);
cart = cart.AddToCart(product.Id, 1);
CartItem item = cart.Build().CartItems.FirstOrDefault();
Assert.Single(cart.Build().CartItems);
Assert.True(cart.RemoveCartItem(new Guid()));
Assert.Single(cart.Build().CartItems);
}
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
CategoryBuilder.BuildCategory(modelBuilder);
OrderBuilder.BuildOrder(modelBuilder);
OrderLineBuilder.BuildOrderLine(modelBuilder);
CartBuilder.BuildCart(modelBuilder);
ProductBuilder.BuildProduct(modelBuilder);
UserProfileBuilder.BuildUserProfile(modelBuilder);
CartLineBuilder.BuildCartLine(modelBuilder);
base.OnModelCreating(modelBuilder);
}
public void CalculateShippingCost_NoItems_Return0(Address source, Address destination)
{
// We could have used auto mocking container here as well, however at the moment this initialization is simple as it is
var target = new ShippingCalculator(source);
var cart = new CartBuilder()
.WithShippingAddress(destination)
.Build();
var result = target.CalculateShippingCost(cart);
Assert.Equal(0, result);
}
public void RemoveById_CartFound_RemoveFromDb()
{
var target = new FakeShoppingCartRepository(_databaseSettings);
var cart1 = new CartBuilder().WithId(null).WithCustomerId("1").Build();
target.Create(cart1);
target.Remove(cart1.Id);
var result = target.FindById(cart1.Id);
Assert.Null(result);
}
public void RemoveItemFromCart_ItemWithProductIdNotFoundNotFound_ReturnNotFound()
{
var cart = new CartBuilder().Build();
var fakeShoppingCartRepository = _mocker.GetMock <IShoppingCartRepository>();
fakeShoppingCartRepository.Setup(x => x.FindById("cart-1")).Returns(cart);
var target = _mocker.CreateInstance <ShoppingCartController>();
var result = target.RemoveItemFromCart("cart-1", "item-1");
Assert.IsType <NotFoundResult>(result);
}
public void AccumulateCartItemQuantityTest()
{
var product = new ProductBuilder().Constructer(ProductName, Desc, Quantity, Price);
var cart = new CartBuilder().Constructer(CartName);
cart = cart.AddToCart(product.Id, 1);
CartItem item = cart.Build().CartItems.FirstOrDefault();
cart = cart.AccumulateCartItemQuantity(item.Id, 2);
Assert.Single(cart.Build().CartItems);
Assert.Equal(3, cart.Build().CartItems.FirstOrDefault().Quantity);
}
public void Inicialize()
{
driver = new ChromeDriver();
this.bestSellersBuilder = new BestSellersBuilder(driver);
this.addToCartBuilder = new AddToCartBuilder(driver);
this.cartBuilder = new CartBuilder(driver);
this.enumHelper = new EnumHelper();
this.wait = new WebDriverWait(driver, System.TimeSpan.FromSeconds(30));
driver.Navigate().GoToUrl("http://automationpractice.com");
driver.Manage().Window.Maximize();
}
public void Update_CartFound_UpdateValue()
{
var target = new FakeShoppingCartRepository(_databaseSettings);
var cart1 = new CartBuilder().WithId(null).WithCustomerId("1").Build();
target.Create(cart1);
cart1.CustomerId = "other";
target.Update(cart1.Id, cart1);
var result = target.FindById(cart1.Id);
Assert.Equal("other", cart1.CustomerId);
}
public void CalculateTotals_DiscountBasedOnCustomerType(CustomerType customerType, double expectedDiscount)
{
var address = CreateAddress();
var target = new CheckOutEngine(new ShippingCalculator(address), _mapper, new CouponEngine());
var cart = new CartBuilder()
.WithCustomerType(customerType)
.WithShippingAddress(address)
.Build();
var result = target.CalculateTotals(cart);
Assert.Equal(expectedDiscount, result.CustomerDiscount);
}
public void Creates_A_Cart()
{
var cartBuilder = new CartBuilder();
var address = Builders.Utility.AddressGenerate();
var shoppingCartRepository = new ShoppingCartRepository(_shoppingCartDatabaseSettings);
var cartOne = cartBuilder.GenerateCart(address, CustomerType.Premium, ShippingMethod.Expedited);
var cartTwo = cartBuilder.GenerateCart(address, CustomerType.Premium, ShippingMethod.Express);
var cartThree = cartBuilder.GenerateCart(address, CustomerType.Premium, ShippingMethod.Priority);
shoppingCartRepository.Create(cartOne);
shoppingCartRepository.Create(cartTwo);
shoppingCartRepository.Create(cartThree);
var result = shoppingCartRepository.FindAll();
result.Should().HaveCount(3);
}
