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());
}
