public async Task DeleteOption_DoesNotExist()
{
//Arrange
var productOptionsRepository = new Mock <IAsyncRepository <ProductAggregate.ProductOption> >();
productOptionsRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MockObjects.ProductOption.GetProductOption_Empty())
.Verifiable();
var productRepository = new Mock <IAsyncRepository <ProductAggregate.Product> >();
var controlller = new ProductOptionsController(productRepository.Object, productOptionsRepository.Object);
//Act
var result = await controlller.DeleteOptionAsync(new Guid());
//Assert
var notFoundResult = result as NotFoundResult;
productRepository.Verify();
productRepository.VerifyNoOtherCalls();
Assert.NotNull(notFoundResult);
Assert.Equal(StatusCodes.Status404NotFound, notFoundResult.StatusCode);
}
protected override void ConfigTest()
{
var mock = new Mock <IProductOptionService>();
_mockService = mock;
_testController = new ProductOptionsController(_mockService.Object);
}
public async Task GetOption_OptionExists()
{
//Arrange
var productOptionsRepository = new Mock <IAsyncRepository <ProductAggregate.ProductOption> >();
productOptionsRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MockObjects.ProductOption.GetProductOption())
.Verifiable();
var productRepository = new Mock <IAsyncRepository <ProductAggregate.Product> >();
var controlller = new ProductOptionsController(productRepository.Object, productOptionsRepository.Object);
//Act
var result = await controlller.GetOptionAsync(new Guid());
//Assert
var okObjectResult = result as OkObjectResult;
var product = okObjectResult.Value as object;
productRepository.Verify();
Assert.NotNull(okObjectResult);
Assert.NotNull(product);
}
public void GetAllProductOptions_ShouldReturnAllOptionsOfProduct()
{
ProductOptionsController controller = new ProductOptionsController(this.mockContext.Object);
IQueryable <ProductOption> result = controller.GetProductOption(product.First().Id);
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Count());
}
public void Init()
{
_fixture = new Fixture();
_fixture.Behaviors.Remove(new ThrowingRecursionBehavior());
_fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_mapper = new Mock <IMapper>();
_productService = new Mock <IProductService>();
_productOptionsService = new Mock <IProductOptionService>();
_productOptionsController = new ProductOptionsController(_productService.Object, _productOptionsService.Object, _mapper.Object);
}
public void DeleteProductOption_ShouldReturnCorrectStatusCode()
{
ProductOptionsController controller = new ProductOptionsController(this.mockContext.Object);
IHttpActionResult response = controller.DeleteProductOption(productOptions.First().Id);
var result = (StatusCodeResult)response;
Assert.IsNotNull(response);
Assert.AreEqual(200, (int)result.StatusCode);
}
public void GetProductOptionById_ShouldReturnCorrectProductOption()
{
ProductOptionsController controller = new ProductOptionsController(this.mockContext.Object);
IHttpActionResult response = controller.GetOption(product.First().Id, productOptions.First().Id);
var result = response as OkNegotiatedContentResult <ProductOption>;
var productResult = result.Content;
Assert.IsNotNull(response);
Assert.IsNotNull(productResult);
Assert.AreEqual(productOptions.First().Id, productResult.Id);
}
public async Task CreateOption_ProductExists()
{
//Arrange
var productRepository = new Mock <IAsyncRepository <ProductAggregate.Product> >();
productRepository.Setup(repo => repo.UpdateAsync(It.IsAny <ProductAggregate.Product>()))
.Callback(
(ProductAggregate.Product p) =>
{
p.ProductOptions =
p.ProductOptions.Select
(option => new ProductAggregate.ProductOption()
{
Name = option.Name,
Description = option.Description,
Product = p,
ProductId = p.Id,
Id = new Guid()
}).ToList();
});
productRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MockObjects.Product.GetProduct())
.Verifiable();
var productOptionRepository = new Mock <IAsyncRepository <ProductAggregate.ProductOption> >();
var controlller = new ProductOptionsController(productRepository.Object, productOptionRepository.Object);
//Act
var productOptionDTO = MockObjects.ProductOption.GetProductOptionDTO();
var productGuid = new Guid();
var result = await controlller.CreateOptionAsync(productGuid, productOptionDTO);
var createdResult = result as CreatedResult;
var productOption = createdResult.Value as Messages.ProductOption;
//Assert
productRepository.Verify();
Assert.NotNull(createdResult);
Assert.NotNull(productOption);
Assert.NotNull(productOption.Id);
Assert.Equal(productOptionDTO.Name, productOption.Name);
Assert.Equal(productOptionDTO.Description, productOption.Description);
Assert.Equal(StatusCodes.Status201Created, createdResult.StatusCode);
}
public async Task DeleteProductShouldReturnOkWhenSuccess()
{
// Arrange
_productOptionService.Setup(x => x.DeleteProductOption(It.IsAny <DeleteProductOptionCommand>())).ReturnsAsync(CommandResponseDto.Success);
var controller = new ProductOptionsController(_productOptionService.Object);
// Act
var response = await controller.DeleteOption(Guid.NewGuid());
// Assert
Assert.IsInstanceOfType(response, typeof(OkResult));
}
public async Task GetOptionShouldReturnResponseDto()
{
// Arrange
_productOptionService.Setup(x => x.GetById(It.IsAny <Guid>())).ReturnsAsync(new QueryResponseDto <ProductOptionResponseDto>(new ProductOptionResponseDto()));
var controller = new ProductOptionsController(_productOptionService.Object);
// Act
var response = await controller.GetOption(Guid.NewGuid());
// Assert
Assert.IsInstanceOfType(response, typeof(OkNegotiatedContentResult <ProductOptionResponseDto>));
}
public async Task CreateProductOptionShouldReturnErrorWhenFail()
{
// Arrange
_productOptionService.Setup(x => x.CreateProductOption(It.IsAny <CreateProductOptionCommand>())).ReturnsAsync(CommandResponseDto.Fail("Error message!"));
var controller = new ProductOptionsController(_productOptionService.Object);
// Act
var response = await controller.CreateOption(Guid.NewGuid(), new ProductOptionRequestDto());
// Assert
Assert.IsInstanceOfType(response, typeof(BadRequestErrorMessageResult));
Assert.AreEqual(((BadRequestErrorMessageResult)response).Message, "Error message!");
}
public async Task GetOptionShouldBadRequestWhenFail()
{
// Arrange
_productOptionService.Setup(x => x.GetById(It.IsAny <Guid>())).ReturnsAsync(new QueryResponseDto <ProductOptionResponseDto>("Error!"));
var controller = new ProductOptionsController(_productOptionService.Object);
// Act
var response = await controller.GetOption(Guid.NewGuid());
// Assert
Assert.IsInstanceOfType(response, typeof(BadRequestErrorMessageResult));
Assert.AreEqual(((BadRequestErrorMessageResult)response).Message, "Error!");
}
public void UpdateProductOption_CorrectStatusCode()
{
ProductOptionsController controller = new ProductOptionsController(this.mockContext.Object);
var new_productOption = new ProductOption
{
Name = "Demo1Updated",
Description = "Description1Updated",
};
IHttpActionResult response = controller.UpdateProductOption(productOptions.First().Id, new_productOption);
var result = (StatusCodeResult)response;
Assert.IsNotNull(response);
Assert.AreEqual(200, (int)result.StatusCode);
}
public void when_returning_a_product_option_then_existence_of_product_should_get_validated_first()
{
// Arrange:
var productServiceMock = new Mock <IProductService>();
productServiceMock.Setup(m => m.GetProductById(It.IsAny <Guid>())).Returns(default(Product));
var productOptionServiceMock = new Mock <IProductOptionService>();
var productsController = new ProductOptionsController(productServiceMock.Object, productOptionServiceMock.Object);
// Act:
Action getProductOption = () => productsController.GetOption(Guid.NewGuid(), Guid.NewGuid());
// Assert:
Assert.Throws <HttpResponseException>(getProductOption);
}
public void CreateProductOption_ShouldReturnCorrectProductOption()
{
ProductOptionsController controller = new ProductOptionsController(this.mockContext.Object);
ProductOption _productOption = new ProductOption {
Id = Guid.NewGuid(), ProductId = product.First().Id, Name = "New_Product_Option", Description = "New_Product_Option_Description"
};
IHttpActionResult response = controller.CreateOption(product.First().Id, _productOption);
var result = response as CreatedAtRouteNegotiatedContentResult <ProductOption>;
var productResult = result.Content;
Assert.IsNotNull(response);
Assert.IsNotNull(productResult);
Assert.AreEqual(_productOption.Id, productResult.Id);
}
public void TestInitialize()
{
// Initialize database connection factory
var connectionString = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
_dbConnectionFactory = new DbConnectionFactory(connectionString);
// initialize repositories
var productOptionRepository = new ProductOptionRepository(_dbConnectionFactory);
var productRepository = new ProductRepository(_dbConnectionFactory, productOptionRepository);
// initialize controllers
_productController = new ProductsController(productRepository);
_productOptionController = new ProductOptionsController(productOptionRepository);
InitializeDatabase();
}
public async Task UpdateOption_Exists()
{
//Arrange
//Setup product repository
var productRepository = new Mock <IAsyncRepository <ProductAggregate.Product> >();
//Setup product options repository
var productOptionRepository = new Mock <IAsyncRepository <ProductAggregate.ProductOption> >();
productOptionRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MockObjects.ProductOption.GetProductOption())
.Verifiable();
productOptionRepository.Setup(repo => repo.UpdateAsync(It.IsAny <ProductAggregate.ProductOption>()))
.Verifiable();
var controlller = new ProductOptionsController(productRepository.Object, productOptionRepository.Object);
//Act
var productOptionDTO = MockObjects.ProductOption.GetProductOptionDTO();
var productGuid = new Guid();
var result = await controlller.UpdateOptionAsync(productGuid, productOptionDTO);
var createdResult = result as CreatedResult;
var productOption = createdResult.Value as Messages.ProductOption;
//Assert
productRepository.Verify();
productRepository.VerifyNoOtherCalls();
Assert.NotNull(createdResult);
Assert.NotNull(productOption);
Assert.NotNull(productOption.Id);
Assert.Equal(productOptionDTO.Name, productOption.Name);
Assert.Equal(productOptionDTO.Description, productOption.Description);
Assert.Equal(StatusCodes.Status201Created, createdResult.StatusCode);
}
public async Task DeleteOption_Exists()
{
//Arrange
var productOptionsRepository = new Mock <IAsyncRepository <ProductAggregate.ProductOption> >();
productOptionsRepository.Setup(repo => repo.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(MockObjects.ProductOption.GetProductOption())
.Verifiable();
var productRepository = new Mock <IAsyncRepository <ProductAggregate.Product> >();
var controlller = new ProductOptionsController(productRepository.Object, productOptionsRepository.Object);
//Act
var result = await controlller.DeleteOptionAsync(new Guid());
//Assert
var acceptedResult = result as StatusCodeResult;
productRepository.Verify();
Assert.NotNull(acceptedResult);
Assert.Equal(StatusCodes.Status202Accepted, acceptedResult.StatusCode);
}
public ProductsController(IProductsRepository productRepository, IProductOptionsRepository productOptionsRepository, IMapper mapper)
{
_ProductController = new ProductController(productRepository, mapper);
_ProductOptionsController = new ProductOptionsController(productOptionsRepository, mapper);
}
public void Setup()
{
productOptionsController = new ProductOptionsController();
}
public ProductOptionsControllerTests()
{
_productsController = new ProductOptionsController(_mediator.Object);
}
public ProductOptionsControllerTests()
{
_mockProductService = new Mock <IProductService>();
_sut = new ProductOptionsController(_mockProductService.Object);
}
