public async void CreateProduct_Incorrect_NewProductValue_Returns_BadRequest()
{
// Arrange
ProductForCreationDto productDto = null;
// Act
var result = await sut.CreateProduct(productDto);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public async void ShouldReturn200WhenProductCreationSucceeds()
{
// Arrange
_mediator.Setup(m => m.Send(It.IsAny <CreateProductCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new CommandResult <ProductDto>(new ProductDto()));
// Act
var actionResult = await _productsController.CreateProduct(new ProductCreateDto()) as ObjectResult;
// Assert
Assert.NotNull(actionResult);
Assert.Equal(StatusCodes.Status200OK, actionResult.StatusCode.Value);
}
public async Task CreateProduct_Returns_BadResponse_If_Exception_Is_Thrown()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
CreateProductRequest createProductRequest = new CreateProductRequest
{
Name = "Test Product 1",
Description = "Description 1",
Price = 2000M,
DeliveryPrice = 10M
};
mockProductService.Setup(m => m.CreateProduct(It.IsAny <CreateProductRequest>()))
.ThrowsAsync(new Exception("Error occured!"))
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.CreateProduct(createProductRequest) as BadRequestObjectResult;
var responseObject = response.Value as ApiResult;
//Assert
Assert.Equal("An error has occured", responseObject.Error);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public async Task CreateProduct_Returns_OkResponse_Successfully()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
CreateProductRequest createProductRequest = new CreateProductRequest
{
Name = "Test Product 1",
Description = "Description 1",
Price = 2000M,
DeliveryPrice = 10M
};
mockProductService.Setup(m => m.CreateProduct(It.IsAny <CreateProductRequest>()))
.ReturnsAsync(new CreateProductResponse
{
IsSuccessful = true
})
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.CreateProduct(createProductRequest) as OkObjectResult;
var responseObject = response.Value as CreateProductResponse;
//Assert
Assert.True(responseObject.IsSuccessful);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public void CreateValidProduct()
{
// Arrange
var mockService = new Mock <IProductDomainService>();
var testProduct = new Product()
{
Id = Guid.NewGuid(),
Name = "Guasha"
};
mockService.Setup(ms => ms.CreateProduct(It.IsAny <Product>()))
.Returns(testProduct);
var controller = new ProductsController(mockService.Object);
// Act
var testRequest = new ProductRequest()
{
Name = "Guasha"
};
var check = controller.CreateProduct(testRequest);
// Assert
var result = Assert.IsType <ProductResponse>(check);
Assert.Equal(testProduct.Id, result.Id);
}
public async Task CreateProduct()
{
_productLogic.Setup(mockRepo => mockRepo.CreateAsync(It.IsNotNull <IProduct>())).ReturnsAsync(_expectedProduct);
_slExpectedProduct.Validate("err loc");
var actualProduct = await _controller.CreateProduct(_slExpectedProduct);
AssertProductsAreEqual(_slExpectedProduct, actualProduct);
}
public void Create_ExistingProduct_ShouldReturnConflictResult()
{
var product = new ProductDto
{
ProductID = 1,
ProductName = "Test Existing Product",
CategoryID = 3,
UnitPrice = new decimal(999.99),
QuantityPerUnit = "0",
SupplierID = 22
};
_mockRepository.Setup(r => r.Exists(product.ProductID)).Returns(true);
var result = _controller.CreateProduct(product);
Assert.IsInstanceOfType(result, typeof(ConflictResult));
}
public void Create_A_Product_WhenCalled_ReturnsOkResult()
{
var product = new Product()
{
Id = 1, Name = "Guitarra", AgeRestriction = 25, Company = "Hasbro", Description = "Just a guitarr", Price = 300
};
var okResult = _controller.CreateProduct(product);
Assert.IsType <OkResult>(okResult.Result);
}
public async Task When_no_product_in_db_then_CreateProduct_creates_product()
{
var product = _fixture.Create <Product>();
var inputModel = _mapper.Map <AddProductInputModel>(product);
var result = await _controller.CreateProduct(inputModel) as CreatedAtActionResult;
product = await _dbContext.Products.FindAsync(result.RouteValues["id"]);
Assert.That(product.Name, Is.EqualTo(inputModel.Name));
}
public void Create_ExistingProduct_ShouldReturnConflictResult()
{
var controller = new ProductsController();
var productDto = new ProductDto
{
Name = "Test Existing Product",
Description = "This product already exists.",
Price = new decimal(123.45),
DeliveryPrice = new decimal(67.89)
};
controller.CreateProduct(productDto);
var result = controller.CreateProduct(productDto);
controller.DeleteProduct(productDto.Id);
Assert.IsInstanceOfType(result, typeof(ConflictResult));
}
public void CreateProduct_ShouldReturnCorrectProduct()
{
ProductsController controller = new ProductsController(this.mockContext.Object);
Product _product = new Product {
Id = Guid.NewGuid(), Name = "NewProduct", Description = "New_Product_Description", Price = 15.00M, DeliveryPrice = 20.00M
};
IHttpActionResult response = controller.CreateProduct(_product);
var result = response as CreatedAtRouteNegotiatedContentResult <Product>;
var productResult = result.Content;
Assert.IsNotNull(response);
Assert.IsNotNull(productResult);
Assert.AreEqual(_product.Id, productResult.Id);
}
public void CreateProduct_ValidProductCreated_ReturnCreated()
{
using (new TransactionScope())
{
Product product = CreateTestObjects.CreateNewProduct("G15", "Keyboard for gaming.", "Logitech", 125.4m, 2);
HttpMethod test = new HttpMethod("Test");
_controller.Request = new HttpRequestMessage(test, "/");
_controller.Configuration = new HttpConfiguration();
var result = _controller.CreateProduct(product) as CreatedNegotiatedContentResult <Product>;
Assert.IsNotNull(result);
Assert.AreEqual(product.ProductId, result.Content.ProductId);
}
}
public void CreateProduct_ValidProductCreated_ReturnCreated()
{
Product product = new Product()
{
ProductId = 2
};
HttpMethod test = new HttpMethod("Test");
_controller.Request = new HttpRequestMessage(test, "/");
_controller.Configuration = new HttpConfiguration();
var result = _controller.CreateProduct(product) as CreatedNegotiatedContentResult <Product>;
Assert.IsNotNull(result);
Assert.AreEqual(product.ProductId, result.Content.ProductId);
}
public void Create_NewProduct_ShouldReturnOk()
{
var controller = new ProductsController();
var productDto = new ProductDto
{
Id = Guid.NewGuid(),
Name = "New Product",
Description = "Add new product.",
Price = new decimal(123.45),
DeliveryPrice = new decimal(67.89)
};
var result = controller.CreateProduct(productDto);
controller.DeleteProduct(productDto.Id);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public void Update_ExistingProduct_ShouldReturnOK()
{
var controller = new ProductsController();
var productDto = new ProductDto
{
Name = "Test Updating Existing Product",
Description = "This product will be upated.",
Price = new decimal(123.45),
DeliveryPrice = new decimal(67.89)
};
controller.CreateProduct(productDto);
var result = controller.UpdateProduct(productDto.Id, productDto);
controller.DeleteProduct(productDto.Id);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public void Delete_ExistingProduct_ShouldReturnOk()
{
var controller = new ProductsController();
var context = new ApplicationDbContext();
var productDto = new ProductDto
{
Id = Guid.NewGuid(),
Name = "Test Product to delete ",
Description = "Add new product to delete.",
Price = new decimal(123.45),
DeliveryPrice = new decimal(67.89)
};
controller.CreateProduct(productDto);
var result = controller.DeleteProduct(productDto.Id);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public async Task CreateProduct_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 productRepository = new ProductRepository(loggerRepository, mapper, blobService, 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 GetCreateProduct_ShouldReturnCreateView_ReturnsView()
{
var expectedCategories = _fixture.CreateMany <Categories>(5);
_categoriesService.Setup(service => service.GetCategoriesAsync())
.ReturnsAsync(expectedCategories).Verifiable();
var expectedSuppliers = _fixture.CreateMany <Suppliers>(5);
_supplierService.Setup(service => service.GetSuppliersAsync())
.ReturnsAsync(expectedSuppliers).Verifiable();
var controller = new ProductsController(
_productsService.Object,
_categoriesService.Object,
_supplierService.Object,
_configuration.Object,
_mapper,
_logger.Object);
// Act
var result = await controller.CreateProduct();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var actualModel = Assert.IsAssignableFrom <ProductWriteItemViewModel>(
viewResult.ViewData.Model);
Assert.Equal(expectedSuppliers.Count(), actualModel.Suppliers.Count());
Assert.Equal(expectedSuppliers.Count(), actualModel.Suppliers.Count());
_productsService.Verify();
_categoriesService.Verify();
_productsService.Verify();
}