public async Task Create_Success()
{
// Arrange
var loggerController = Loggers.CategoryController();
var mapper = Mapper.Get();
var dbContext = _fixture.Context;
var categoryRequest = NewDatas.NewCategoryRequest();
var categoryRepository = new CategoryRepository(mapper, dbContext);
var catgoriesController = new CategoriesController(loggerController, categoryRepository);
// Act
var result = await catgoriesController.Create(categoryRequest);
// Assert
var createdCategoryResult = Assert.IsType <CreatedResult>(result.Result);
var resultValue = Assert.IsType <CategoryRespone>(createdCategoryResult.Value);
Assert.Equal(categoryRequest.Name, resultValue.Name);
Assert.Equal(categoryRequest.Description, resultValue.Description);
Assert.Equal(categoryRequest.Image, resultValue.Image);
}
public async void GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
rating.User = user;
rating.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
dbContext.Ratings.Add(rating);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.GetRatings();
// Assert
var ratingResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(ratingResult.Value as IEnumerable <Rating>);
}
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 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 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(int rateValue, string comment)
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
rating.User = user;
rating.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
dbContext.Ratings.Add(rating);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.PostRating(user.Id, product.productId, rateValue, comment);
// Assert
var ratingResult = Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.NotNull(ratingResult.Value as Rating);
}
public async Task GetSingle_Success()
{
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
var product3 = NewDatas.NewProduct();
await dbContext.Products.AddRangeAsync(product1, product2, product3);
await dbContext.SaveChangesAsync();
var order = NewDatas.NewOrder();
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync();
var orderDetail1 = NewDatas.NewOrderDetail();
orderDetail1.productId = product1.productId;
orderDetail1.orderId = order.orderId;
var orderDetail2 = NewDatas.NewOrderDetail();
orderDetail2.productId = product2.productId;
orderDetail2.orderId = order.orderId;
var orderDetail3 = NewDatas.NewOrderDetail();
orderDetail3.productId = product3.productId;
orderDetail3.orderId = order.orderId;
await dbContext.OrderDetails.AddRangeAsync(orderDetail1, orderDetail2, orderDetail3);
await dbContext.SaveChangesAsync();
order.orderDetails = new List <OrderDetail> {
orderDetail1, orderDetail2, orderDetail3
};
order.user = user;
await dbContext.SaveChangesAsync();
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
// Act
var result = await ordersController.GetOrder(order.orderId);
// Assert
var ordersResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotNull(ordersResult.Value as Order);
}
public async void GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
var product2 = NewDatas.NewProduct();
var product3 = NewDatas.NewProduct();
await dbContext.Products.AddRangeAsync(product1, product2, product3);
await dbContext.SaveChangesAsync();
#region create intial order data
var fileService = FileServiceMock.FilesService();
var order = NewDatas.NewOrder();
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync();
var orderDetail1 = NewDatas.NewOrderDetail();
orderDetail1.productId = product1.productId;
orderDetail1.orderId = order.orderId;
var orderDetail2 = NewDatas.NewOrderDetail();
orderDetail2.productId = product2.productId;
orderDetail2.orderId = order.orderId;
var orderDetail3 = NewDatas.NewOrderDetail();
orderDetail3.productId = product3.productId;
orderDetail3.orderId = order.orderId;
await dbContext.OrderDetails.AddRangeAsync(orderDetail1, orderDetail2, orderDetail3);
await dbContext.SaveChangesAsync();
order.orderDetails = new List <OrderDetail> {
orderDetail1, orderDetail2, orderDetail3
};
order.user = user;
await dbContext.SaveChangesAsync();
#endregion
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
// Act
var result = await ordersController.GetOrders();
// Assert
var ordersResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotEmpty(ordersResult.Value as IEnumerable <OrderResponse>);
}
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 Post_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var productToPost = NewDatas.NewProductPostRequest();
var productsService = new ProductService(dbContext, fileService, mapper);
var productsController = new ProductsController(productsService, fileService);
// Act
var result = await productsController.PostProduct(productToPost);
// Assert
Assert.IsType <CreatedAtActionResult>(result.Result);
}
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 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 Post_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
await dbContext.Products.AddAsync(product1);
await dbContext.SaveChangesAsync();
var orderCreateRequest = NewDatas.NewOrderDetailRequest();
orderCreateRequest.productId = product1.productId;
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
#region set controller user
ordersController.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString(CultureInfo.InvariantCulture))
}, "Bearer")
)
}
};
#endregion
// Act
var result = await ordersController.PostOrder(orderCreateRequest);
// Assert
var ordersResult = Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.NotNull(ordersResult.Value as Order);
}
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 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 GetAll_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var product1 = NewDatas.NewProduct();
dbContext.Products.Add(product1);
dbContext.SaveChanges();
var productsService = new ProductService(dbContext, fileService, mapper);
var productsController = new ProductsController(productsService, fileService);
// Act
var result = await productsController.GetProducts();
// 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 Put_Success()
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
string commentToPut, commentAfterPut;
commentToPut = commentAfterPut = "Comment Changed";
int valueToPut, valueAfterPut;
valueToPut = valueAfterPut = 5;
rating.User = user;
rating.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
dbContext.Ratings.Add(rating);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.PutRating(rating.ratingId, user.Id, product.productId, valueToPut, commentToPut);
// Assert
var ratingResult = Assert.IsType <OkObjectResult>(result);
Assert.Equal((ratingResult.Value as Rating).rateValue, valueAfterPut);
Assert.Equal((ratingResult.Value as Rating).comment, commentAfterPut);
}
public async Task GetSingle_Success(int id)
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var user1 = NewDatas.NewUser();
var user2 = NewDatas.NewUser();
var product = NewDatas.NewProduct();
var rating = NewDatas.NewRating();
rating.User = user1;
rating.Product = product;
var rating1 = NewDatas.NewRating();
rating1.User = user2;
rating1.Product = product;
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
dbContext.Users.AddRange(user1, user2);
await dbContext.SaveChangesAsync();
dbContext.Ratings.AddRange(rating, rating1);
await dbContext.SaveChangesAsync();
var ratingsService = new RatingService(dbContext);
var ratingsController = new RatingsController(ratingsService, mapper);
// Act
var result = await ratingsController.GetRatingByProductId(id);
// Assert
var ratingResult = Assert.IsType <OkObjectResult>(result.Result);
Assert.NotNull(ratingResult.Value);
}
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 Put_Success(int quantity)
{
// Arrange
var dbContext = _fixture.Context;
var mapper = MapperMock.Get();
var fileService = FileServiceMock.FilesService();
var user = NewDatas.NewUser();
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var product1 = NewDatas.NewProduct();
await dbContext.Products.AddRangeAsync(product1);
await dbContext.SaveChangesAsync();
#region create intial order data
var order = NewDatas.NewOrder();
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync();
var orderDetail1 = NewDatas.NewOrderDetail();
orderDetail1.productId = product1.productId;
orderDetail1.orderId = order.orderId;
int initialQuantity = orderDetail1.quantity;
await dbContext.OrderDetails.AddRangeAsync(orderDetail1);
await dbContext.SaveChangesAsync();
order.orderDetails = new List <OrderDetail> {
orderDetail1
};
order.user = user;
await dbContext.SaveChangesAsync();
#endregion
var orderCreateRequest = NewDatas.NewOrderDetailRequest();
orderCreateRequest.productId = product1.productId;
orderCreateRequest.quantity = quantity;
int afterPostQuantity = quantity;
var ordersService = new OrderService(dbContext, mapper);
var ordersController = new OrdersController(ordersService, mapper, fileService);
#region set controller user
ordersController.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString(CultureInfo.InvariantCulture))
}, "Bearer")
)
}
};
#endregion
// Act
var result = await ordersController.PostOrder(orderCreateRequest);
// Assert
var ordersResult = Assert.IsType <CreatedAtActionResult>(result.Result);
var productInOrderResult = (ordersResult.Value as Order).orderDetails.First(x => x.productId == product1.productId);
Assert.Equal(productInOrderResult.quantity, initialQuantity + afterPostQuantity);
}
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);
}
