public void DeleteProduct_ReturnsTrue_MatchingId(int id)
{
var expectedResponse = true;
IHttpActionResult controllerResponse = productsController.DeleteProduct(id);
var actualResponse = controllerResponse as OkNegotiatedContentResult <bool>;
Assert.AreEqual(expectedResponse, actualResponse.Content);
}
public void Delete_Product_ShouldReturnOk()
{
var product = new Product();
_mockRepository.Setup(p => p.GetProductById(product.ProductID)).Returns(product);
var result = _controller.DeleteProduct(product.ProductID);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public void DeleteProduct_DeleteProductWithCorrectId_ReturnOk()
{
Product product = new Product()
{
ProductId = 2
};
_mockRepository.Setup(r => r.GetProductById(product.ProductId)).Returns(product);
var result = _controller.DeleteProduct(product.ProductId);
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public async void ShouldReturn200WhenProductDeleteSucceeds()
{
// Arrange
_mediator.Setup(m => m.Send(It.IsAny <DeleteProductCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new CommandResult <bool>(true));
// Act
var actionResult =
await _productsController.DeleteProduct(Guid.NewGuid()) as ObjectResult;
// Assert
Assert.NotNull(actionResult);
Assert.Equal(StatusCodes.Status200OK, actionResult.StatusCode.Value);
}
public async Task DeleteProduct_ReturnsDeletedProduct()
{
var productInDb = await _repository.GetAllProducts();
var productId = productInDb.FirstOrDefault().Id;
var result = await productsController.DeleteProduct(productId);
var okobjectresult = result.Result as OkObjectResult;
var product = okobjectresult.Value as Product;
Assert.IsType <OkObjectResult>(result.Result);
Assert.Equal(product.Id, productId);
}
public async void Task3_Post_New_Product_FindName()
{
//Arrange
_context = new SDCContext(dbContextOptions);
_controller = new ProductsController(_context);
var product = new Product()
{
SupplierId = 1,
ProductId = "NewPKItem"
};
//Act
var result = await _controller.PostProduct(product);
//Assert
var okResult = result.Should().BeOfType <CreatedAtActionResult>().Subject;
var resProduct = okResult.Value.Should().BeAssignableTo <Product>().Subject;
resProduct.ProductId.Should().Be("NewPKItem");
//delete JayNew
int SupplierId = _context.Product.FirstOrDefault(p => p.ProductId == "NewPKItem").SupplierId;
string ProductId = _context.Product.FirstOrDefault(p => p.ProductId == "NewPKItem").ProductId;
var resultDelete = await _controller.DeleteProduct(ProductId, SupplierId);
}
public void Delete_NoExistingProduct_ShouldReturnNotFound()
{
var controller = new ProductsController();
var result = controller.DeleteProduct(Guid.NewGuid());
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void DeleteProduct_RemovesProduct()
{
var init = _context.Products.Count();
var product = _context.Products.SingleOrDefault(x => x.Description == "Delete Me");
Assert.IsNotNull(product);
var result = _controller.DeleteProduct(product.Id);
var count = _context.Products.Count();
Assert.IsNotNull(result);
Assert.IsInstanceOf <OkNegotiatedContentResult <string> >(result);
Assert.AreEqual(init - 1, count);
}
public async Task DeleteProduct_Returns_OkResponse_Successfully()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
Guid productId = Guid.Parse("de1287c0-4b15-4a7b-9d8a-dd21b3cafec3");
mockProductService.Setup(m => m.DeleteProduct(productId))
.ReturnsAsync(new DeleteProductResponse
{
IsSuccessful = true
})
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.DeleteProduct(productId) as OkObjectResult;
var responseObject = response.Value as DeleteProductResponse;
//Assert
Assert.True(responseObject.IsSuccessful);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public async Task DeleteProduct_Returns_BadResponse_If_Exception_Is_Thrown()
{
//Arrange
Mock <ILogger <ProductsController> > mockLogger = new Mock <ILogger <ProductsController> >();
Mock <IProductService> mockProductService = new Mock <IProductService>();
Guid productId = Guid.Parse("de1287c0-4b15-4a7b-9d8a-dd21b3cafec3");
mockProductService.Setup(m => m.DeleteProduct(productId))
.ThrowsAsync(new Exception("Error occured!"))
.Verifiable();
ProductsController productsController = new ProductsController(mockLogger.Object, mockProductService.Object);
//Act
var response = await productsController.DeleteProduct(productId) as BadRequestObjectResult;
var responseObject = response.Value as ApiResult;
//Assert
Assert.Equal("An error has occured", responseObject.Error);
mockLogger.VerifyAll();
mockProductService.VerifyAll();
}
public void Delete_Newly_Created_Product()
{
//Arrange
var productName = "Deleted Sause";
var productID = 0;
// We will create the product first then check its there then delete it.
var product = new ProductViewModel
{
ProductName = productName,
UnitPrice = 2,
SupplierID = 1,
CategoryID = 1,
UnitsInStock = 100
};
ProductsController productsController = new ProductsController(new BuildModelsService());
var productHttpResponse = productsController.PutProduct(product);
var productViewModel = (ProductViewModel)((System.Net.Http.ObjectContent)productHttpResponse.Content).Value;
productID = productViewModel.ProductID;
// Act
var productDeleteHttpResponse = productsController.DeleteProduct(productID);
//Assert
productDeleteHttpResponse.StatusCode.Should().Be(HttpStatusCode.NoContent);
}
public async Task DeleteItem_ShouldReturnUnauthorized_IfClientIsNotAdmin()
{
int mockProdId = 1;
int mockClientId = 1;
var mockRepo = new Mock <ICustomerRepository>();
var mockMapper = new Mock <IMapper>();
Client client = new Client {
Id = 1,
IsAdmin = false
};
mockRepo.Setup(repo => repo.GetCustomer(mockClientId)).ReturnsAsync(client);
mockRepo.Setup(repo => repo.DeleteProduct(mockProdId)).ReturnsAsync(true);
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.DeleteProduct(mockProdId, mockClientId);
Assert.IsType <UnauthorizedResult>(res);
}
public async Task DeleteProduct()
{
_productLogic.Setup(mock => mock.Delete(_expectedProduct.Id.ToString())).ReturnsAsync(_expectedProduct);
var actualProduct = await _controller.DeleteProduct(_slExpectedProduct.Id);
AssertProductsAreEqual(_slExpectedProduct, actualProduct);
}
public async Task DeleteProduct_ReturnBadRequest_ExistRelatedEntity()
{
//Arrange
int id = 1;
List <OrderDetail> list = new List <OrderDetail>();
list.Add(new OrderDetail());
_mockrepo.Setup(repo => repo.OrderDetail.OrderDetailsByProduct(id)).ReturnsAsync(list);
_mockrepo.Setup(repo => repo.Product.DeleteProduct((Product)null));
//Act
var result = await _controller.DeleteProduct(id);
//Assert
var badRequest = Assert.IsType <BadRequestObjectResult>(result);
badRequest.Value.Should().Be(LogMessage.DeleteError(nameof(Product), id, nameof(OrderDetail)));
}
public void DeleteProductDeletsProduct()
{
int id = 6;
var deletedProduct = controller.DeleteProduct(id);
List <Product> productList = (List <Product>)controller.GetProducts();
Assert.IsTrue(productList.Count == 5, "Should have 5 products returned.");
}
public void DeleteFail()
{
Prd P = new Prd(db);
ProductsController obj = new ProductsController(P);
BadRequestResult data = (BadRequestResult)obj.DeleteProduct(290);
//BadRequestResult data = (BadRequestResult)controller.DeleteProduct(290);
Assert.AreEqual(400, data.StatusCode);
}
public void DeleteProduct_DeleteProductWithCorrectId_ReturnOk()
{
using (new TransactionScope())
{
Product product = CreateTestObjects.CreateNewProduct("G15", "Keyboard for gaming.", "Logitech", 125.4m, 2);
_context.Products.Add(product);
_context.SaveChanges();
var checkIfExistsInDB = _controller.GetProducts(product.ProductId) as OkNegotiatedContentResult <Product>;
var result = _controller.DeleteProduct(product.ProductId);
var findIfDeleted = _controller.GetProducts(product.ProductId) as OkNegotiatedContentResult <Product>;
Assert.IsInstanceOfType(result, typeof(OkResult));
Assert.IsNotNull(checkIfExistsInDB);
Assert.IsNull(findIfDeleted);
}
}
public void DeletePass()
{
Prd P = new Prd(db);
ProductsController obj = new ProductsController(P);
ObjectResult data = (ObjectResult)obj.DeleteProduct(2);
// ObjectResult data = (ObjectResult)controller.DeleteProduct(2);
Assert.AreEqual(200, data.StatusCode);
}
public async void DeleteProductWithIncorrectIdReturnsNotFound()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
var result = await controller.DeleteProduct(99);
Assert.IsType <NotFoundResult>(result);
}
}
public void DeleteProduct_ShouldReturnCorrectStatusCodet()
{
ProductsController controller = new ProductsController(this.mockContext.Object);
IHttpActionResult response = controller.DeleteProduct(product.First().Id);
var result = (StatusCodeResult)response;
Assert.IsNotNull(response);
Assert.AreEqual(200, (int)result.StatusCode);
}
public async Task When_DeleteProduct_called_then_product_removed_from_DB()
{
var product = _products[1];
await _controller.DeleteProduct(product.Id);
product = await _dbContext.Products.FindAsync(product.Id);
Assert.That(product, Is.Null);
}
public async Task Delete_product()
{
var service = new ProductsController(_mockContext.Object);
await service.DeleteProduct(1);
_mockSet.Verify(m => m.FindAsync(1),
Times.Once());
_mockSet.Verify(x => x.Remove(_product), Times.Once);
_mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()),
Times.Once());
}
public void GivenAProduct_WhenDeletingAsAnAdmin_TheProductIsMarkedAsDeleted()
{
var entityId = 5;
var fakeProduct = new Product {
Id = 1, Status = ProductStatus.Active, EntityId = entityId
};
var fakeProducts = Enumerable.Range(0, 200)
.Select(id => id == 1 ? fakeProduct : new Product {
Id = id
});
contextMock.SetupGet(r => r.Products).Returns(fakeProducts.ToDbSet());
authorizationServiceMock.Setup(r => r.HasRole(GlobalRole.Admin)).Returns(true);
var response = productsController.DeleteProduct(1);
Assert.IsInstanceOfType(response, typeof(OkResult));
contextMock.Verify(r => r.SaveChanges(), Times.Once);
Assert.AreEqual(ProductStatus.Deleted, fakeProduct.Status);
}
public async Task Product_Delete()
{
// Act
var actionResult = await _controller.DeleteProduct(1);
//Assert
var okResult = actionResult.Should().BeOfType <OkObjectResult>().Subject;
var product = okResult.Value.Should().BeAssignableTo <Product>().Subject;
product.Id.Should().Be(1);
}
public async void DeleteProductModelStateErrorReturnsBadRequest()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
controller.ModelState.AddModelError("an error", "some error");
var result = await controller.DeleteProduct(1);
Assert.IsType <BadRequestObjectResult>(result);
}
}
public void DeleteProdust_WhenNotExist()
{
// Arrange
var mockService = new Mock <IProductDomainService>();
Guid testId = Guid.NewGuid();
mockService.Setup(ms => ms.DeleteProduct(testId))
.Throws <Exception>();
var controller = new ProductsController(mockService.Object);
// Act & Assert
Assert.Throws <Exception>(() => controller.DeleteProduct(testId));
}
public void DeleteProductTest(Product product, FakeRepository <Product, int> repository)
{
var controller = new ProductsController(repository);
repository.Create(product);
var deleteActionResult = controller.DeleteProduct(product.Id);
var deleteResult = deleteActionResult as OkNegotiatedContentResult <Product>;
Assert.NotNull(deleteResult);
Assert.Equal(product, deleteResult.Content);
Assert.Null(repository.GetById(product.Id));
}
public async Task TestDelete()
{
// Arrange
int id = 4;
ProductsController controller = new ProductsController(context);
var expected = context.Product.Find(id);
// Act
var result = await controller.DeleteProduct(id);
var actual = result.Value;
// Assert
Assert.AreEqual(expected, actual);
}
public void DeleteProduct_ShouldFailWhenThereIsStock()
{
//Arrange
var context = new TestStoreAppContext();
var item = GetDemoProduct();
context.Products.Add(item);
//Act
var controller = new ProductsController(context);
var badresult = controller.DeleteProduct(item.Id);
//Assert
Assert.IsInstanceOfType(badresult, typeof(BadRequestErrorMessageResult));
}
public void Task_DeleteProduct_ReturnsOkResult()
{
var productService = new Mock <IProductService>();
var logger = new Mock <ILogger <ProductsController> >();
var productId = 1;
productService.Setup(x => x.DeleteProduct(productId));
var controller = new ProductsController(productService.Object, logger.Object);
var okResponse = controller.DeleteProduct(productId);
Assert.IsType <OkResult>(okResponse);
}
public void DeleteProduct_ShouldReturnOK()
{
// arrange
var context = new TestStoreAppContext();
var item = this.GetDemoProduct();
context.Products.Add(item);
var controller = new ProductsController(context);
// act
var result = controller.DeleteProduct(3) as OkNegotiatedContentResult<Product>;
// assert
Assert.Equal(item.Id, result.Content.Id);
}
