public async Task Delete_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
await dbContext.AddRangeAsync(category);
await dbContext.SaveChangesAsync();
var categoryRepository = new CategoryRepository(mapper, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.Delete(category.CategoryId);
// Assert
var createdCategoryResult = Assert.IsType <OkObjectResult>(result.Result);
var resultValue = Assert.IsType <CategoryRespone>(createdCategoryResult.Value);
Assert.Equal(category.Name, resultValue.Name);
Assert.Equal(category.Description, resultValue.Description);
Assert.Equal(category.Image, resultValue.Image);
await Assert.ThrowsAsync <NotFoundException>(async() =>
{
await catgoriesController.GetById(resultValue.CategoryId);
});
}
public async Task GetAll_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category1 = NewDatas.NewCategory();
var category2 = NewDatas.NewCategory();
var category3 = NewDatas.NewCategory();
await dbContext.AddRangeAsync(category1, category2, category3);
await dbContext.SaveChangesAsync();
var categoryRepository = new CategoryRepository(mapper, blobService, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.GetAll();
// Assert
var getCategoriesResultType = Assert.IsType <ActionResult <IEnumerable <CategoryRespone> > >(result);
var getCategoriesResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(getCategoriesResult.Value as IEnumerable <CategoryRespone>);
}
public async Task Update_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var oldCategory = NewDatas.NewCategory();
await dbContext.AddAsync(oldCategory);
await dbContext.SaveChangesAsync();
var newCategoryRequest = NewDatas.NewCategoryRequest();
var categoryRepository = new CategoryRepository(mapper, blobService, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.Update(oldCategory.CategoryId, newCategoryRequest);
// Assert
var createdCategoryResult = Assert.IsType <OkObjectResult>(result.Result);
var resultValue = Assert.IsType <CategoryRespone>(createdCategoryResult.Value);
Assert.Equal(oldCategory.Name, resultValue.Name);
Assert.Equal(oldCategory.Description, resultValue.Description);
Assert.Equal(oldCategory.Image, resultValue.Image);
Assert.Equal(oldCategory.Name, newCategoryRequest.Name);
Assert.Equal(oldCategory.Description, newCategoryRequest.Description);
Assert.Equal(oldCategory.Image, newCategoryRequest.Image);
}
public async Task Put_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var productToPut = NewDatas.NewProductPutRequest();
var productBeforePut = NewDatas.NewProduct(); productBeforePut.productId = 10; //set productId in order to update
var productAfterPut = NewDatas.ProductAfterPut();
var category = NewDatas.NewCategory();
await dbContext.Categories.AddAsync(category);
await dbContext.Products.AddAsync(productBeforePut);
await dbContext.SaveChangesAsync(); productToPut.categoryId = category.categoryId;
var productsService = new ProductService(dbContext, fileService, mapper);
var productsController = new ProductsController(productsService, fileService);
// Act
var result = await productsController.PutProduct(10, productToPut);
// Assert
Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(productBeforePut.productName, productAfterPut.productName);
Assert.Equal(productBeforePut.productPrice, productAfterPut.productPrice);
Assert.Equal(productBeforePut.productDescription, productAfterPut.productDescription);
Assert.Equal(productBeforePut.Images.Count, productAfterPut.Images.Count);
Assert.Equal(productBeforePut.Category, category);
}
public async Task Post_Success()
{
// Arrange
var dbContext = _fixture.Context;
var categoryToAdd = NewDatas.NewCategory();
var categoriesService = new CategoryService(dbContext);
var categoriesController = new CategoriesController(categoriesService);
// Act
var result = await categoriesController.Post(categoryToAdd);
// Assert
Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.Equal(1, dbContext.Categories.Count());
}
public async Task UpdateProduct_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var oldCategory = NewDatas.NewCategory();
var newCategory = NewDatas.NewCategory();
await dbContext.Categories.AddRangeAsync(oldCategory, newCategory);
await dbContext.SaveChangesAsync();
var product = NewDatas.NewProduct();
product.CategoryId = oldCategory.CategoryId;
await dbContext.Products.AddAsync(product);
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, blobService, dbContext);
var productRequest = NewDatas.NewProductRequest();
productRequest.CategoryId = newCategory.CategoryId;
// Act
var productController = new ProductsController(loggerController, productRepository);
var result = await productController.UpdateProduct(product.ProductId, productRequest);
// Assert
var updatedResult = Assert.IsType <OkObjectResult>(result.Result);
var updatedValue = Assert.IsType <ProductRespone>(updatedResult.Value);
Assert.Equal(product.Name, updatedValue.Name);
Assert.Equal(product.Price, updatedValue.Price);
Assert.Equal(product.Description, updatedValue.Description);
Assert.Equal(product.Image, updatedValue.Image);
Assert.Equal(product.Rated, updatedValue.Rated);
Assert.Equal(newCategory.CategoryId, updatedValue.CategoryId);
Assert.Equal(newCategory.Name, updatedValue.CategoryName);
}
public async void GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
dbContext.Categories.Add(category);
dbContext.SaveChanges();
var categoriesService = new CategoryService(dbContext);
var categoriesController = new CategoriesController(categoriesService);
// Act
var result = await categoriesController.GetCategories();
// Assert
Assert.IsType <OkObjectResult>(result.Result);
}
public async Task Delete_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var blobService = BlobService.BlobServiceUpload();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
await dbContext.Categories.AddRangeAsync(category);
await dbContext.SaveChangesAsync();
var product = NewDatas.NewProduct();
product.CategoryId = category.CategoryId;
await dbContext.Products.AddAsync(product);
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, blobService, dbContext);
var productController = new ProductsController(loggerController, productRepository);
// Act
var result = await productController.RemoveProduct(product.ProductId);
// Assert
var deletedResult = Assert.IsType <OkObjectResult>(result.Result);
var deletedResultValue = Assert.IsType <ProductRespone>(deletedResult.Value);
Assert.Equal(product.Name, deletedResultValue.Name);
Assert.Equal(product.Price, deletedResultValue.Price);
Assert.Equal(product.Description, deletedResultValue.Description);
Assert.Equal(product.Image, deletedResultValue.Image);
Assert.Equal(product.Rated, deletedResultValue.Rated);
Assert.Equal(category.CategoryId, deletedResultValue.CategoryId);
Assert.Equal(category.Name, deletedResultValue.CategoryName);
await Assert.ThrowsAsync <NotFoundException>(async() =>
{
await productController.GetProduct(deletedResultValue.ProductId);
});
}
public async Task GetById_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
await dbContext.Categories.AddAsync(category);
await dbContext.SaveChangesAsync();
await dbContext.Products.AddRangeAsync(product1, product2);
product1.CategoryId = category.CategoryId;
product2.CategoryId = category.CategoryId;
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, dbContext);
var productController = new ProductsController(loggerController, productRepository);
// Act
var result = await productController.GetProduct(product1.ProductId);
// Assert
var productResult = Assert.IsType <OkObjectResult>(result.Result);
var productValue = Assert.IsType <ProductRespone>(productResult.Value);
Assert.Equal(product1.Name, productValue.Name);
Assert.Equal(product1.Price, productValue.Price);
Assert.Equal(product1.Description, productValue.Description);
Assert.Equal(product1.Image, productValue.Image);
Assert.Equal(product1.Rated, productValue.Rated);
Assert.Equal(category.CategoryId, productValue.CategoryId);
Assert.Equal(category.Name, productValue.CategoryName);
}
public async Task GetSingle_Success(int id)
{
// Arrange
var dbContext = _fixture.Context;
var category1 = NewDatas.NewCategory();
var category2 = NewDatas.NewCategory();
await dbContext.Categories.AddRangeAsync(category1, category2);
dbContext.SaveChanges();
var categoriesService = new CategoryService(dbContext);
var categoriesController = new CategoriesController(categoriesService);
// Act
var result = await categoriesController.GetCategory(id);
// Assert
Assert.IsType <OkObjectResult>(result.Result);
}
public async Task Put_Success()
{
// Arrange
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
var categoryPutRequest = NewDatas.CategoryPutRequest();
var categoryAfterPut = NewDatas.CategoryAfterPut();
await dbContext.Categories.AddAsync(category);
await dbContext.SaveChangesAsync();
var categoriesService = new CategoryService(dbContext);
var categoriesController = new CategoriesController(categoriesService);
// Act
var result = await categoriesController.Put(category.categoryId, categoryPutRequest);
// Assert
Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(category.categoryName, categoryAfterPut.categoryName);
}
public async Task CreateProduct_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
await dbContext.Categories.AddRangeAsync(category);
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, dbContext);
var productRequest = NewDatas.NewProductRequest();
productRequest.CategoryId = category.CategoryId;
// Act
var productController = new ProductsController(loggerController, productRepository);
var result = await productController.CreateProduct(productRequest);
// Assert
var createdResult = Assert.IsType <CreatedResult>(result.Result);
var returnValue = Assert.IsType <ProductRespone>(createdResult.Value);
Assert.Equal(productRequest.Name, returnValue.Name);
Assert.Equal(productRequest.Price, returnValue.Price);
Assert.Equal(productRequest.Description, returnValue.Description);
Assert.Equal(productRequest.Image, returnValue.Image);
Assert.Equal(0, returnValue.Rated);
Assert.Equal(category.CategoryId, returnValue.CategoryId);
Assert.Equal(category.Name, returnValue.CategoryName);
}
public async Task GetAll_Success()
{
// Arrange
var loggerController = Loggers.ProductControllerLogger();
var loggerRepository = Loggers.ProductRepositoryLogger();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
await dbContext.Categories.AddAsync(category);
await dbContext.SaveChangesAsync();
await dbContext.Products.AddRangeAsync(product1, product2);
product1.CategoryId = category.CategoryId;
product2.CategoryId = category.CategoryId;
await dbContext.SaveChangesAsync();
var productRepository = new ProductRepository(loggerRepository, mapper, dbContext);
var productController = new ProductsController(loggerController, productRepository);
// Act
var result = await productController.GetProducts(null);
// Assert
var getProductsResultType = Assert.IsType <ActionResult <IEnumerable <ProductRespone> > >(result);
var getProductsResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(getProductsResult.Value as IEnumerable <ProductRespone>);
}
public async Task CreateOrder_Success()
{
// Arrange
var loggerRepository = Loggers.OrderRepositoryLogger();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var category = NewDatas.NewCategory();
var user = NewDatas.NewUser();
await dbContext.Categories.AddAsync(category);
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
product1.CategoryId = category.CategoryId;
var product2 = NewDatas.NewProduct();
product2.CategoryId = category.CategoryId;
await dbContext.Products.AddRangeAsync(product1, product2);
await dbContext.SaveChangesAsync();
var contextAccessor = ContextAccesser.mockHttpAccessor(user.Id);
var orderCartRepository = new OrderCartRepository(loggerRepository, contextAccessor, mapper, dbContext);
var orderRequest = new List <CartOrderRequest> {
new CartOrderRequest {
ProductId = product1.ProductId,
Quantity = 3,
},
new CartOrderRequest {
ProductId = product2.ProductId,
Quantity = 2,
},
};
// Act
var orderController = new OrdersController(orderCartRepository);
var result = await orderController.CreateOrder(orderRequest);
// Assert
var orderResultType = Assert.IsType <ActionResult <IEnumerable <CartOrderRespone> > >(result);
var getOrdersResultValue = Assert.IsType <CreatedResult>(result.Result);
var ordersValue = getOrdersResultValue.Value as List <CartOrderRespone>;
Assert.NotEmpty(ordersValue);
var totalPriceReq = (product1.Price * orderRequest[0].Quantity) + (product2.Price * orderRequest[1].Quantity);
var totalPriceRes = 0;
ordersValue.ForEach(order => totalPriceRes += order.Product.Price * order.Quantity);
Assert.Equal(totalPriceReq, totalPriceRes);
}
