public void AddWhenValidObjectPassedReturnsCreatedResponse()
{
var fixture = new Fixture();
Product product = fixture.Create <Product>();
var createdResponse = controller.AddProduct(product);
Assert.IsType <CreatedAtActionResult>(createdResponse);
}
public void Post_ReturnsCreatedResult_WhenObjectIsPassed()
{
var productService = new Mock <IProductService>();
var logger = new Mock <ILogger <ProductsController> >();
var product = new Product();
productService.Setup(x => x.AddProduct(It.Is <Product>(x => x.Id == 4 && x.Name == "Eyeliner" && x.Price == 3M && x.Quantity == 2 && x.Description == "Cosmetics"))).Returns(product);
var controller = new ProductsController(productService.Object, logger.Object);
var actualResult = controller.AddProduct(
new Product()
{
Id = 4,
Name = "Eyeliner",
Price = 3M,
Quantity = 2,
Description = "Cosmetics"
});
Assert.NotNull(actualResult);
Assert.Equal(product, actualResult);
Assert.IsType <Product>(actualResult);
}
public void AddProduct_Should_Return_Added_Product_If_Product_Is_Not_Null()
{
// Arrange
var dbProducts = Fixtures.Products;
var newProduct = new ProductDTO {
ID = 8, Name = "New Product", Price = 10
};
var manager = new Mock <IProductManager>();
manager.Setup(m => m.AddProduct(newProduct)).Returns(() =>
{
dbProducts.Add(newProduct);
return(Task.FromResult(dbProducts.FirstOrDefault(p => p.ID == dbProducts.Count)));
});
var logger = new Mock <ILogger <ProductsController> >();
var controller = new ProductsController(manager.Object, logger.Object);
// Act
var task = controller.AddProduct(newProduct);
task.Wait();
var result = task.Result;
var actionResult = (ObjectResult)result.Result;
// Assert
Assert.AreEqual(StatusCodes.Status200OK, actionResult.StatusCode);
Assert.AreEqual(newProduct, actionResult.Value);
}
public void GivenAnEntity_WhenSubmittingAProductAsTheEntityOwner_TheProductIsAddedToTheEntityProducts()
{
var fakeEntityId = 2;
var fakeProduct = new Product {
};
var productSetMock = new Mock <DbSet <Product> >();
authorizationServiceMock.Setup(r => r.HasRole(fakeEntityId, EntityRole.Owner)).Returns(true);
contextMock.SetupGet(r => r.Products).Returns(productSetMock.Object);
var result = productsController.AddProduct(fakeEntityId, fakeProduct);
Assert.IsInstanceOfType(result, typeof(CreatedResult));
productSetMock.Verify(r => r.Add(fakeProduct), Times.Once);
contextMock.Verify(r => r.SaveChanges());
}
public async Task AddProduct_ReturnsOkObjectResult()
{
//Arrange
var expectedResult = _fixture.Build <Product>().Create();
_mockProductsService.Setup(x => x.AddProduct(expectedResult)).ReturnsAsync(expectedResult);
//Act
var actualResult = Assert.IsType <OkObjectResult>(await _productsController.AddProduct(expectedResult));
//Assert
Assert.NotNull(actualResult);
Assert.Equal(StatusCodes.Status200OK, actualResult.StatusCode);
Assert.IsType <Product>(actualResult.Value);
Assert.Equal(expectedResult, actualResult.Value);
_mockProductsService.VerifyAll();
}
public void AddProduct()
{
// Get products for the first time and check return.
var beforeAddProductsCount = GetProducts().Count();
// Add a product.
Controller.AddProduct(new Product
{
Brand = $"new brand {DateTime.UtcNow.Ticks}",
Description = $"new description {DateTime.UtcNow.Ticks}",
Model = $"new model {DateTime.UtcNow.Ticks}",
});
// Get products for the second time and check return.
var afterAddProductsCount = GetProducts().Count();
// Compare the count of products returned in previous get call.
Assert.Equal(afterAddProductsCount, beforeAddProductsCount + 1);
}
public void AddProductShould_ReturnsView()
{
//Arrange
var productServiceMock = new Mock <IProductsService>();
var categoryServiceMock = new Mock <ICategoryService>();
ProductsController controller = new ProductsController(productServiceMock.Object, categoryServiceMock.Object);
// Act
ViewResult result = controller.AddProduct() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public async Task AddProduct_ReturnBadRequest_EmptyRequest()
{
var mockRepo = new Mock <IProductRepository>();
var controller = new ProductsController(mockRepo.Object);
controller.ModelState.AddModelError("", "empty body");
var result = await controller.AddProduct(null);
Assert.IsType <ActionResult <DefaultResponse> >(result);
var okResult = Assert.IsType <BadRequestObjectResult>(result.Result);
var response = Assert.IsType <MBadRequest>(okResult.Value);
Assert.Equal((int)StatusCodes.BadRequest, response.status);
}
public void ProductsCrud()
{
var options = CreateOptions("ProductsCrud");
using (var context = new ApplicationDbContext(options))
{
var controller =
new ProductsController(
new ProductsService(
context));
Assert.That(
controller.ListProducts(0).Count == 0,
"Test database should be empty, but found at least one product");
// Products per page == 50, adding 51 products means we should be able
// to access one full page and one partial page through the controller
for (int i = 0; i < 51; i++)
{
controller.AddProduct(new Product
{
Name = "Test",
Description = "Unit Test Product",
Price = i * 5
});
}
}
using (var context = new ApplicationDbContext(options))
{
var controller =
new ProductsController(
new ProductsService(
context));
Assert.That(
controller.ListProducts(0).Count == 50,
"Number of products on first page is not 50 when controller " +
"page length is and there are at least 50 products in the database. " +
"Has the page length changed?");
Assert.That(
controller.ListProducts(1).Count == 1,
"Number of products on second page is not one when there are " +
"51 products in the data base and there are 50 products per page. " +
"Has the page length changed?");
}
}
public void TestAddProductFail()
{
using (var context = new ProductDbContext(builder.Options))
{
SetUpTestData(context);
IProductRepository productRepository = new ProductRepository(context);
ProductsController productController = new ProductsController(productRepository, null);
Func <Task> act = async() => await productController.AddProduct(new ProductDto
{
Id = products[0].Id
});
act.Should().Throw <HttpResponseException>();
context.Database.EnsureDeleted();
}
}
public void AddProductShould_CallAddProduct()
{
//Arrange
var productServiceMock = new Mock <IProductsService>();
var categoryServiceMock = new Mock <ICategoryService>();
ProductsController controller = new ProductsController(productServiceMock.Object, categoryServiceMock.Object);
Category category = new Category();
Product product = new Product()
{
Category = category
};
ProductViewModel viewModel = new ProductViewModel(product);
// Act
controller.AddProduct(viewModel);
// Assert
productServiceMock.Setup(p => p.AddProduct(product)).Verifiable();
}
public async Task AddProduct_ShouldReturnOkObjectResult_IfClientIsAdmin()
{
int mockClientId = 1;
var mockRepo = new Mock <ICustomerRepository>();
var mockMapper = new Mock <IMapper>();
Client client = new Client {
Id = 1,
IsAdmin = true
};
Product prodToAdd = new Product {
Id = 1,
Name = "Dummy name",
Description = "Dummy Description",
Price = 24.5,
Status = "AVAILABLE"
};
ProductForCreationDto p1 = new ProductForCreationDto {
Name = prodToAdd.Name,
Description = prodToAdd.Description, Price = prodToAdd.Price, Status = prodToAdd.Status
};
mockRepo.Setup(repo => repo.GetCustomer(mockClientId)).ReturnsAsync(client);
mockRepo.Setup(repo => repo.AddProduct(prodToAdd)).ReturnsAsync(prodToAdd);
var controller = new ProductsController(mockRepo.Object, mockMapper.Object);
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.Name, "Just Name"),
new Claim(ClaimTypes.NameIdentifier, "1")
}));
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var res = await controller.AddProduct(p1, client.Id);
Assert.IsType <OkObjectResult>(res);
}
public void Should_Be_Able_To_Add_Product()
{
//set up
MockDependencies();
var product = new Product {
Brand = "Sony", Description = "smart TV", Id = "1", Model = "tv1"
};
mockIQueryHandler.Setup(x => x.Handle <string, Result <Product> >(It.IsAny <string>())).Returns(() => Result.Ok(product));
mockICommandHandler.Setup(x => x.Handle <ProductForUpdateDto>(It.IsAny <ProductForUpdateDto>()));
//arrange
var productToInsert = new ProductForCreationDto
{
Brand = "Sony", Description = "Sony", Model = "", Id = "1"
};
var productController = new ProductsController(mockIQueryHandler.Object, mockICommandHandler.Object, configuration.CreateMapper());
var result = productController.AddProduct(productToInsert) as BadRequestObjectResult;
//test
result.StatusCode.Value.Should().Be(200, "Brand and description are same");
}
public void AddProduct_Should_Return_Bad_Request_If_Product_Is_Null()
{
// Arrange
var dbProducts = Fixtures.Products;
var manager = new Mock <IProductManager>();
manager.Setup(m => m.AddProduct(null)).Returns(Task.FromResult(dbProducts.FirstOrDefault(p => p.ID == dbProducts.Count)));
var logger = new Mock <ILogger <ProductsController> >();
var controller = new ProductsController(manager.Object, logger.Object);
// Act
var task = controller.AddProduct(null);
task.Wait();
var result = task.Result;
var actionResult = (ObjectResult)result.Result;
// Assert
Assert.AreEqual(StatusCodes.Status400BadRequest, actionResult.StatusCode);
}
