public void AddProductInShoppingCartWithInvalidUserShouldNotAddProduct() { var options = new DbContextOptionsBuilder <XeonDbContext>() .UseInMemoryDatabase(databaseName: "AddProductInShoppingCartWithInvalidUser_Database") .Options; var dbContext = new XeonDbContext(options); var username = "******"; XeonUser user = null; var userService = new Mock <IUsersService>(); userService.Setup(r => r.GetUserByUsername(username)) .Returns(user); var productId = 1; var productService = new Mock <IProductsService>(); productService.Setup(p => p.GetProductById(productId)) .Returns(new Product { Name = "USB Cable" }); var shoppingCartsService = new ShoppingCartsService(dbContext, productService.Object, userService.Object); shoppingCartsService.AddProductInShoppingCart(productId, username); var shoppingCartProducts = dbContext.ShoppingCartProducts.ToList(); Assert.Empty(shoppingCartProducts); }
public void GetOrderByIdAndUserId_WithExistentId_ShouldReturnCorrectResults() { string errorMessagePrefix = "OrdersService GetOrderByIdAndUserId() method does not work properly."; var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); UniShopUser user = context.Users.First(); Order order = new Order { OrderStatus = OrderStatus.Processed, UniShopUserId = user.Id, }; context.Add(order); context.SaveChanges(); OrderServiceModel expectedResults = user.Orders.First().To <OrderServiceModel>(); OrderServiceModel actualResults = this.orderService.GetOrderByIdAndUserId(expectedResults.Id, user.Id); Assert.True(expectedResults.Id == actualResults.Id, errorMessagePrefix + " " + "Id is not returned properly."); Assert.True(expectedResults.OrderStatus == actualResults.OrderStatus, errorMessagePrefix + " " + "OrderStatus is not returned properly."); Assert.True(expectedResults.UniShopUserId == actualResults.UniShopUserId, errorMessagePrefix + " " + "UniShopUserId Count is not returned properly."); }
public void ShouldCallCommitMethodOfUnitOfWorkOnce_WhenOperationsAreDone(string cartId) { // Arrange var shoppingCart = new ShoppingCart(); var product = new Mock <Product>(); var mockedUnitOfWork = new Mock <IUnitOfWork>(); mockedUnitOfWork.Setup(uow => uow.Commit()).Verifiable(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(scr => scr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Remove(1, cartId); // Assert mockedUnitOfWork.Verify(uow => uow.Commit(), Times.Once); }
public void DeliverOrder_WithCorrectData_ShouldChangeOrderStatusToDelivered() { string errorMessagePrefix = "OrdersService DeliverOrder() method does not work properly."; var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); UniShopUser user = context.Users.First(); Order order = new Order { OrderStatus = OrderStatus.Processed, UniShopUserId = user.Id, }; context.Add(order); context.SaveChanges(); OrderStatus expectedOrderStatus = OrderStatus.Delivered; bool actualResult = this.orderService.DeliverOrder(order.Id); OrderStatus actualOrderStatus = order.OrderStatus; Assert.True(actualResult, errorMessagePrefix); Assert.Equal(expectedOrderStatus, actualOrderStatus); }
public void CreateOrder_WithoutProductsInShoppingCart_ShouldReturnFalse() { string errorMessagePrefix = "OrdersService CreateOrder() method does not work properly."; var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); UniShopUser user = context.Users.First(); int supplierId = context.Suppliers.First().Id; int addressId = user.Addresses.First().Id; int expectedCount = user.Orders.Count(); bool actualResult = this.orderService.CreateOrder(user.UserName, supplierId, 1, addressId); int actualCount = user.Orders.Count(); Assert.False(actualResult, errorMessagePrefix); Assert.Equal(expectedCount, actualCount); }
public void AnyProductsShouldReturnFalseWhenThereAreNotAnyProducts() { var options = new DbContextOptionsBuilder <XeonDbContext>() .UseInMemoryDatabase(databaseName: $"АnyProductsFalse_Database") .Options; var dbContext = new XeonDbContext(options); var user = new XeonUser { UserName = "******", ShoppingCart = new ShoppingCart() }; dbContext.Users.Add(user); var product = new Product { Name = "USB Cable" }; dbContext.Products.Add(product); dbContext.SaveChanges(); var userService = new Mock <IUsersService>(); userService.Setup(r => r.GetUserByUsername(user.UserName)) .Returns(user); var productService = new Mock <IProductsService>(); var shoppingCartsService = new ShoppingCartsService(dbContext, productService.Object, userService.Object); var areThereAnyProducts = shoppingCartsService.AnyProducts(user.UserName); Assert.False(areThereAnyProducts); }
public void ShouldCallGetByIdMethodOfShoppingCartRepository() { // Arrange var cartId = "42-424"; var shoppingCart = new ShoppingCart(); var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(scr => scr.GetById(It.IsAny <string>())) .Returns(shoppingCart) .Verifiable(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.GetCart(cartId); // Assert mockedShoppingCartRepository.Verify(scr => scr.GetById(cartId), Times.Once); }
public void GetOrderByIdAndUserId_WithNonCorrectData_ShouldReturnNull() { string errorMessagePrefix = "OrdersService GetOrderByIdAndUserId() method does not work properly."; var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); string userId = context.Users.First().Id; string nonExistentUserId = userId + new Guid(); Order order = new Order { OrderStatus = OrderStatus.Processed, UniShopUserId = userId, }; context.Add(order); context.SaveChanges(); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); OrderServiceModel actualResults = this.orderService.GetOrderByIdAndUserId(order.Id, nonExistentUserId); Assert.True(actualResults == null, errorMessagePrefix); }
public void ShouldClearShoppingCartTemporaryProducts() { // Arrange var cartProduct = new CartProduct(); var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct, cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Clear(shoppingCart); // Assert Assert.AreEqual(0, shoppingCart.TemporaryProducts.Count); }
public void ShouldReturnCorrectAmountOfTemporaryCartProductsInShoppingCart() { // Arrange var cartId = "42-424"; var expectedCount = 2; var cartProduct = new CartProduct(); var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct, cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(scr => scr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act var count = shoppingCartsService.CartProductsCount(cartId); // Assert Assert.AreEqual(expectedCount, count); }
public void AddProductInShoppingCartWithInvalidProductShouldNotAddProduct() { var options = new DbContextOptionsBuilder <XeonDbContext>() .UseInMemoryDatabase(databaseName: "AddProductInShoppingCartWithInvalidProduct_Database") .Options; var dbContext = new XeonDbContext(options); var username = "******"; var user = new XeonUser { UserName = username, ShoppingCart = new ShoppingCart() }; dbContext.Users.Add(user); dbContext.SaveChanges(); var userService = new Mock <IUsersService>(); userService.Setup(r => r.GetUserByUsername(username)) .Returns(dbContext.Users.FirstOrDefault(x => x.UserName == username)); var productId = 1; Product product = null; var productService = new Mock <IProductsService>(); productService.Setup(p => p.GetProductById(productId)) .Returns(product); var shoppingCartsService = new ShoppingCartsService(dbContext, productService.Object, userService.Object); shoppingCartsService.AddProductInShoppingCart(productId, username); var shoppingCartProducts = dbContext.ShoppingCartProducts.ToList(); Assert.Empty(shoppingCartProducts); }
public void GetAllShoppingCartProductsShouldReturnAllShoppingCartProductsForUser() { var options = new DbContextOptionsBuilder <XeonDbContext>() .UseInMemoryDatabase(databaseName: $"GetAllShoppingCartProducts_Database") .Options; var dbContext = new XeonDbContext(options); var products = new List <Product> { new Product { Name = "USB 1.0" }, new Product { Name = "USB 2.0" }, new Product { Name = "USB 3.0" }, new Product { Name = "USB 4.0" } }; dbContext.Products.AddRange(products); var shoppingCartProducts = new List <ShoppingCartProduct> { new ShoppingCartProduct { Product = products.First() }, new ShoppingCartProduct { Product = products.Last() }, }; var user = new XeonUser { UserName = "******", ShoppingCart = new ShoppingCart { ShoppingCartProducts = shoppingCartProducts } }; dbContext.Users.Add(user); dbContext.SaveChanges(); var userService = new Mock <IUsersService>(); userService.Setup(r => r.GetUserByUsername(user.UserName)) .Returns(user); var productService = new Mock <IProductsService>(); var shoppingCartsService = new ShoppingCartsService(dbContext, productService.Object, userService.Object); var shoppingCatrProducts = shoppingCartsService.GetAllShoppingCartProducts(user.UserName); Assert.Equal(2, shoppingCatrProducts.Count()); }
public void EditProductQuantityInShoppingCartShouldEditProductQuantity(int quantity, int expectedQuantity) { var options = new DbContextOptionsBuilder <XeonDbContext>() .UseInMemoryDatabase(databaseName: "EditProductQuantityInShoppingCart_Database") .Options; var dbContext = new XeonDbContext(options); var product = new Product { Name = "USB 1.0" }; dbContext.Products.AddRange(product); var shoppingCart = new ShoppingCart { ShoppingCartProducts = new List <ShoppingCartProduct> { new ShoppingCartProduct { Product = product, Quantity = 1 }, } }; var username = "******"; var user = new XeonUser { UserName = username, ShoppingCart = shoppingCart }; dbContext.Users.Add(user); dbContext.SaveChanges(); var userService = new Mock <IUsersService>(); userService.Setup(r => r.GetUserByUsername(username)) .Returns(user); var productService = new Mock <IProductsService>(); productService.Setup(p => p.GetProductById(product.Id)) .Returns(product); var shoppingCartsService = new ShoppingCartsService(dbContext, productService.Object, userService.Object); shoppingCartsService.EditProductQuantityInShoppingCart(product.Id, username, quantity); var shoppingCartProduct = dbContext.ShoppingCartProducts .FirstOrDefault(x => x.ProductId == product.Id && x.ShoppingCartId == user.ShoppingCartId); Assert.Equal(expectedQuantity, shoppingCartProduct.Quantity); }
public async Task ReturnCart_AccountId_IsValid() { //Arrange var options = new DbContextOptionsBuilder <GameStoreContext>() .UseInMemoryDatabase("ReturnCart_AccountId_IsValid").Options; var validUser = new Account { UserName = $"TestUsername", FirstName = "FirstName", LastName = "LastName" }; var cart = new ShoppingCart { ShoppingCartProducts = new List <ShoppingCartProducts>() }; var cartProd = new ShoppingCartProducts() { }; var product = new Product { Name = "Test", Description = "test description", ShoppingCartProducts = new List <ShoppingCartProducts>(), Comments = new List <Comment>() }; using (var curContext = new GameStoreContext(options)) { curContext.Accounts.Add(validUser); curContext.ShoppingCarts.Add(cart); validUser.ShoppingCart = cart; cartProd.Product = product; cartProd.ShoppingCart = cart; cart.ShoppingCartProducts.Add(cartProd); curContext.SaveChanges(); //Act var sut = new ShoppingCartsService(curContext); var result = await sut.GetUserCartAsync(validUser.Id); Assert.AreEqual(cart, result); } }
public void ShouldIncreaseFoundTemporaryProductQuantityFromShoppingCart_WhenProductIsFoundInTheTemporaryProducts() { // Arrange var cartId = "42-123"; var quantity = 4; var product = new Product() { Id = 42 }; // Temporary products is empty and it shouldn't find product var cartProduct = new CartProduct() { Product = product, ProductId = product.Id }; var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); mockedCartProductFactory.Setup(cpf => cpf.CreateCartProduct(It.IsAny <int>(), It.IsAny <Product>())) .Returns(cartProduct) .Verifiable(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(shr => shr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act var quantityBefore = cartProduct.Quantity; shoppingCartsService.Add(quantity, product, cartId); var quantityAfter = cartProduct.Quantity; // Assert Assert.AreEqual(quantityBefore, quantityAfter - quantity); }
public void ShouldAddProductToPermanentProductsOfShoppingCart_WhenShoppingCartIsFoundAndProductIsNotInThePermanentProducts() { // Arrange var cartId = "42-123"; var quantity = 2; var product = new Product() { Id = 42 }; var cartProduct = new CartProduct() { Product = product, ProductId = product.Id }; var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); mockedCartProductFactory.Setup(cpf => cpf.CreateCartProduct(It.IsAny <int>(), It.IsAny <Product>())) .Returns(cartProduct) .Verifiable(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(shr => shr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act var countBefore = shoppingCart.PermamentProducts.Count; shoppingCartsService.Add(quantity, product, cartId); var countAfter = shoppingCart.PermamentProducts.Count; // Assert Assert.AreEqual(countBefore, countAfter - 1); }
public void ShouldThrowArgumentNullException_WhenNullShoppingCartIsPassed() { // Arrange var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act and Assert Assert.Throws <ArgumentNullException>(() => shoppingCartsService.AssignShoppingCart(null)); }
public void ShouldCalculateTotalOfFoundPermanentProductFromShoppingCart_WhenProductIsFoundInThePermanentProducts() { // Arrange var cartId = "42-123"; var quantity = 4; var price = 12; var product = new Product() { Id = 42, DiscountedPrice = price }; // Temporary products is empty and it shouldn't find product var cartProduct = new CartProduct() { Product = product, ProductId = product.Id }; var shoppingCart = new ShoppingCart() { PermamentProducts = new List <CartProduct> { cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); mockedCartProductFactory.Setup(cpf => cpf.CreateCartProduct(It.IsAny <int>(), It.IsAny <Product>())) .Returns(cartProduct) .Verifiable(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(shr => shr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Add(quantity, product, cartId); // Assert Assert.AreEqual(cartProduct.Total, quantity * price); }
public void ShouldGetProductFactoryOfCartProductFactoryOnce_WhenShoppingCartIsFoundAndProductIsNotInTheTemporaryProducts() { // Arrange var cartId = "42-123"; var quantity = 2; var product = new Product() { Id = 42 }; var cartProduct = new CartProduct() { Product = product, ProductId = product.Id }; var shoppingCart = new ShoppingCart() { PermamentProducts = new List <CartProduct> { cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); mockedCartProductFactory.Setup(cpf => cpf.CreateCartProduct(It.IsAny <int>(), It.IsAny <Product>())) .Returns(cartProduct) .Verifiable(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(shr => shr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Add(quantity, product, cartId); // Assert mockedCartProductFactory.Verify(cpf => cpf.CreateCartProduct(quantity, product), Times.Once); }
public void ShouldThrowArgumentNullException_WhenNullOrEmptyCartIdIsPassed(string cartId) { // Arrange var product = new Mock <Product>(); var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act and Assert Assert.Throws <ArgumentNullException>(() => shoppingCartsService.Add(1, product.Object, cartId)); }
public void DeliverOrder_WithNonExistentOrder_ShouldReturnFalse() { string errorMessagePrefix = "OrdersService DeliverOrder() method does not work properly."; var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); bool actualResult = this.orderService.DeliverOrder(1000); Assert.False(actualResult, errorMessagePrefix); }
public void ShoulRecalculateTotalOfShoppingCart_WhenCartProductIsRemoved(string cartId, int productId) { // Arrange var price = 10.0M; var quantity = 3; var product = new Product() { Id = productId, DiscountedPrice = price }; var cartProduct = new CartProduct() { Quantity = quantity, Product = product, ProductId = productId }; var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct, cartProduct }, }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); mockedCartProductRepository.Setup(cpr => cpr.Delete(It.IsAny <CartProduct>())) .Callback(() => shoppingCart.TemporaryProducts.Remove(cartProduct)); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(scr => scr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Remove(productId, cartId); var expectedTotal = price * quantity * shoppingCart.TemporaryProducts.Count; // Assert Assert.AreEqual(expectedTotal, shoppingCart.Total); }
public void ShouldCallDeleteMethodOfCartRepositoryTwice_WhenProductWithThisIdIsFoundInTemporaryAndPermanentProducts(string cartId, int productId) { // Arrange var product = new Product() { Id = productId }; var cartProduct = new CartProduct() { Product = product, ProductId = productId }; var shoppingCart = new ShoppingCart() { TemporaryProducts = new List <CartProduct> { cartProduct }, PermamentProducts = new List <CartProduct> { cartProduct } }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); mockedCartProductRepository.Setup(cpr => cpr.Delete(It.IsAny <CartProduct>())) .Verifiable(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(scr => scr.GetById(It.IsAny <string>())) .Returns(shoppingCart); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Remove(productId, cartId); // Assert mockedCartProductRepository.Verify(cpr => cpr.Delete(cartProduct), Times.Exactly(2)); }
public void GetAllUnprocessedOrders_WithZeroData_ShouldReturnEmptyResults() { var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); List <OrderServiceModel> actualResults = this.orderService .GetAllUnprocessedOrders().ToList(); int expectedResults = 0; Assert.Equal(expectedResults, actualResults.Count()); }
public void FindAllUserOrdersShouldReturnAllUserOrders() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: $"FindAllUserOrdersShouldReturnAllUserOrders_Orders_Database") .Options; var dbContext = new ApplicationDbContext(options); var mapper = this.SetUpAutoMapper(); var brandService = new BrandsService(dbContext, mapper); var categoriesService = new CategoriesService(dbContext, mapper); var usersService = new UsersService(dbContext, mapper); var productsService = new ProductsService(dbContext, mapper); var shoppingCartsService = new ShoppingCartsService(dbContext, productsService, usersService, mapper); var ordersService = new OrdersService(dbContext, shoppingCartsService, mapper); var favouritesService = new FavouritesService(dbContext, productsService, usersService, mapper); this.SeeDbdWithBrands(dbContext); this.SeedDbWithCategories(dbContext); var brands = brandService.FindAllBrands(); var categories = categoriesService.FindAllCategories(); var image = new Mock <IFormFile>(); this.SeedDbWithCountries(dbContext); this.SeedDbWithUserAndProduct(dbContext, productsService, mapper.Map <Category>(categories[0]), mapper.Map <Brand>(brands[0]), image.Object); var user = dbContext.Users.FirstOrDefault(x => x.UserName == "1"); var products = productsService.FindAllProducts(); var shoppingCarts = dbContext.ShoppingCarts; var shoppingCartss = dbContext.ShoppingCartProducts; var cart = this.SeedDbShoppingCartWithProducts(dbContext, user.UserName, products[0].Id); var model = this.CreateOrderCreateBindingModel(); var orderId = ordersService.CreateOrder(model, mapper.Map <ApplicationUserDTO>(user)); var orders = ordersService.FindAllUserOrders(mapper.Map <ApplicationUserDTO>(user)); Assert.True(orders.Count == 1); }
public void FindAllCountriesShouldReturnListWithAllCountryNames() { var options = new DbContextOptionsBuilder <ApplicationDbContext>() .UseInMemoryDatabase(databaseName: $"FindAllCountriesShouldReturnListWithAllCountryNames_Orders_Database") .Options; var dbContext = new ApplicationDbContext(options); var mapper = this.SetUpAutoMapper(); var usersService = new UsersService(dbContext, mapper); var productsService = new ProductsService(dbContext, mapper); var shoppingCartsService = new ShoppingCartsService(dbContext, productsService, usersService, mapper); var ordersService = new OrdersService(dbContext, shoppingCartsService, mapper); this.SeedDbWithCountries(dbContext); Assert.True(dbContext.Countries.Count() == ordersService.FindAllCountries().Count); }
public void ShouldCallUpdateMethodOfShoppingCartRepository_WhenAllOperationsAreDone() { // Arrange var cartId = "42-123"; var quantity = 2; var product = new Product(); // Temporary and Permanent products are empty and it shouldn't find product var shoppingCart = new ShoppingCart(); var cartProduct = new CartProduct() { Product = product }; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); mockedCartProductFactory.Setup(cpf => cpf.CreateCartProduct(It.IsAny <int>(), It.IsAny <Product>())) .Returns(cartProduct) .Verifiable(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); mockedShoppingCartRepository.Setup(shr => shr.GetById(It.IsAny <string>())) .Returns(shoppingCart); mockedShoppingCartRepository.Setup(shr => shr.Update(It.IsAny <ShoppingCart>())) .Verifiable(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Add(quantity, product, cartId); // Assert mockedShoppingCartRepository.Verify(shr => shr.Update(shoppingCart), Times.Once); }
public void ShouldZeroShoppingCartTotal() { // Arrange var shoppingCart = new ShoppingCart(); var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act shoppingCartsService.Clear(shoppingCart); // Assert Assert.AreEqual(0, shoppingCart.Total); }
public void ShouldThrowArgumentNullExceptionWithCorrectMessage_WhenNullShoppingCartIsPassed() { // Arrange var expectedExMessage = "Shopping cart cannot be null."; var mockedUnitOfWork = new Mock <IUnitOfWork>(); var mockedCartProductFactory = new Mock <ICartProductFactory>(); var mockedCartProductRepository = new Mock <IGenericRepository <CartProduct> >(); var mockedShoppingCartRepository = new Mock <IGenericRepository <ShoppingCart> >(); var shoppingCartsService = new ShoppingCartsService(mockedUnitOfWork.Object, mockedCartProductFactory.Object, mockedShoppingCartRepository.Object, mockedCartProductRepository.Object); // Act and Assert var exception = Assert.Throws <ArgumentNullException>(() => shoppingCartsService.Clear(null)); StringAssert.Contains(expectedExMessage, exception.Message); }
public void GetAllOrdersByUserId_WithNonExistentUser_ShouldReturnEmptyResults() { var context = UniShopDbContextInMemoryFactory.InitializeContext(); this.SeedData(context); ShoppingCartsService shoppingCartsService = new ShoppingCartsService(context, new UniShopUsersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); this.orderService = new OrdersService(context, new UniShopUsersService(context), shoppingCartsService, new SuppliersService(context), new ProductsService(context, new ChildCategoriesService(context, new ParentCategoriesService(context)))); UniShopUser user = context.Users.First(); List <OrderServiceModel> actualResults = this.orderService .GetAllOrdersByUserId(user.Id).ToList(); int expectedResults = 0; Assert.Equal(expectedResults, actualResults.Count()); }