public async Task DeleteBook_GivenInvalidId_ExpectBadRequest()
{
var result = await _booksController.DeleteBook(-1);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
Assert.AreEqual((result as BadRequestObjectResult).Value, "Id must be greater than 0.");
}
public void DeleteBook_NotExistingIdPassed_ReturnsNotFoundResponse()
{
// Act
var badResponse = controller.DeleteBook(4);
// Assert
Assert.IsType <NotFoundResult>(badResponse.Result.Result);
}
public void TryDeleteInvalidBook()
{
Action <int> deleteAction = id => {
Assert.ThrowsException <AssertFailedException>(() => Controller.DeleteBook(id).GetMessage().AssertStatusCode());
};
deleteAction(-1);
deleteAction(3);
}
public void Remove_NotExistingIdPassed_ReturnsNotFoundResponse()
{
// Arrange
var notExistingId = 150;
// Act
var badResponse = _controller.DeleteBook(notExistingId);
// Assert
Assert.IsType <NotFoundResult>(badResponse);
}
public void DeleteTest_DeletesBookById()
{
// Act
int bookId = 100;
var result = _booksController.DeleteBook(bookId).Result.Result as OkObjectResult;
var book = result.Value as Book;
// Assert
Assert.Equal(bookId, book.Id);
Assert.Equal(200, result.StatusCode);
}
public void DeleteExistingBookTest()
{
mockBookDbSet.Setup(x => x.Remove(It.Is <Book>(b => b.Id == 1))).Verifiable();
//mockBookDbSet.Setup(x => x.Remove(It.IsAny<Book>())).Callback<Book>(b =>
// {
// Assert.AreEqual(b.Id, 1);
// }
//);
var deletedBook = booksController.DeleteBook(1);
//Verify checks that any Setup marked Verifiable actually happened
mockBookDbSet.Verify();
}
public void ReturnBookDto_WhenValidUser_CallsDeleteBook()
{
var id = 1;
var result = new BookDto
{
Id = id,
UserId = 1
};
var bookRepository = A.Fake <IBookRepository>();
A.CallTo(() => bookRepository.BookExists(id)).Returns(true);
A.CallTo(() => bookRepository.GetBook(id)).Returns(result);
var userHelper = A.Fake <IUserHelper>();
A.CallTo(() => userHelper.MatchingUsers(A <HttpContext> .Ignored, result.UserId)).Returns(true);
var controller = new BooksController(bookRepository, null, userHelper, null, null);
var response = controller.DeleteBook(id);
A.CallTo(() => bookRepository.Delete(id)).MustHaveHappened();
Assert.AreEqual(result.Id, response.Value.Id);
}
public void ReturnUnauthorized_WhenInvalidUser_CallsDeleteBook()
{
var id = 1;
var result = new BookDto
{
Id = id,
UserId = 1
};
var bookRepository = A.Fake <IBookRepository>();
A.CallTo(() => bookRepository.BookExists(id)).Returns(true);
A.CallTo(() => bookRepository.GetBook(id)).Returns(result);
var userHelper = A.Fake <IUserHelper>();
A.CallTo(() => userHelper.MatchingUsers(A <HttpContext> .Ignored, result.UserId)).Returns(false);
var controller = new BooksController(bookRepository, null, userHelper, null, null);
var response = controller.DeleteBook(id);
Assert.AreEqual((int)HttpStatusCode.Unauthorized, ((UnauthorizedResult)response.Result).StatusCode);
}
public async Task TestDeleteBook()
{
using (var context = new bookAPIContext(options))
{
BooksController booksController = new BooksController(context, mapper);
ActionResult <Book> result = await booksController.DeleteBook(1);
Assert.AreEqual(context.Book.Count(), 1); // 1 book should remain after deleting book id 1
}
}
public void DeleteBookTest()
{
BooksController controller = new BooksController();
controller.DeleteBook("9418951247361");
var result = controller.GetAllBooks() as List <Book>;
Assert.AreEqual(1, result.Count);
}
public async Task DeleteBook_True()
{
int bookId = 1;
_mockBooksLogic.Setup(x => x.DeleteBook(It.IsAny <int>())).ReturnsAsync(true);
var resultRes = await _controller.DeleteBook(bookId);
Assert.AreEqual(((ObjectResult)resultRes).Value, true);
Assert.AreEqual((int)HttpStatusCode.OK, ((ObjectResult)resultRes).StatusCode);
}
public async Task DeleteBookAsync_ShouldReturnOK()
{
var context = new TestContext();
var item = GetTestBook();
context.Books.Add(item);
var controller = new BooksController(context);
var result = await controller.DeleteBook(3) as OkNegotiatedContentResult <Book>;
Assert.IsNotNull(result);
Assert.AreEqual(item.BookId, result.Content.BookId);
}
public async Task DeleteBook_ReturnsActionResult()
{
// Arrange
var httpContext = new DefaultHttpContext();
_httpContextAccessorMock.Setup(_ => _.HttpContext).Returns(httpContext);
var controller = new BooksController(_bookRepositoryMock.Object, _mapperMock.Object, _httpContextAccessorMock.Object);
// Act
var response = await controller.DeleteBook(1);
// Assert
Assert.IsAssignableFrom <ActionResult>(response);
}
public async Task DeleteBook_Id_NonExistent_ReturnsNotFound()
{
// Arrange
var httpContext = new DefaultHttpContext();
_httpContextAccessorMock.Setup(_ => _.HttpContext).Returns(httpContext);
var controller = new BooksController(_bookRepositoryMock.Object, _mapperMock.Object, _httpContextAccessorMock.Object);
// Act
var response = await controller.DeleteBook(9999);
// Assert
Assert.IsType <NotFoundObjectResult>(response);
}
public void DeleteBook_validId()
{
// Arrange:
var controller = new BooksController(_booksService, _reviewsService);
// Act:
var result = controller.DeleteBook(3);
var noContentResult = result as NoContentResult;
// Assert:
Assert.IsNotNull(result);
Assert.AreEqual(204, noContentResult.StatusCode);
}
public void ReturnBadRequest_WhenBookDoesNotExist_OnCallToDeleteBook()
{
var id = 1;
var bookRepository = A.Fake <IBookRepository>();
A.CallTo(() => bookRepository.BookExists(id)).Returns(false);
var controller = new BooksController(bookRepository, null, null, null, null);
var response = controller.DeleteBook(id);
Assert.AreEqual((int)HttpStatusCode.BadRequest, ((BadRequestObjectResult)response.Result).StatusCode);
Assert.AreEqual($"Book with Id {id} does not exist.", ((BadRequestObjectResult)response.Result).Value);
}
public void DeleteMethod()
{
// Arrange
var mockRepository = new Mock <IBookRepository>();
mockRepository.Setup(x => x.GetBook(10))
.Returns(new Book {
Id = 10
});
var controller = new BooksController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.DeleteBook(10);
// Assert
Assert.IsInstanceOfType(actionResult, typeof(OkResult));
}
public async Task DeleteApiBookTest()
{
//Arrange
long rmId = 2;
Book rmUser = new Book {
Title = "Learning Java", Author = " Patrick Niemeyer, Daniel Leuck"
};
Mock <InMemoryRepository> mockRepo = new Mock <InMemoryRepository>(MockBehavior.Strict);
mockRepo.Setup(x => x.Books.Remove(rmUser));
BooksController booksController = new BooksController(mockRepo.Object);
//Act
IActionResult actionResult = await booksController.DeleteBook(rmId);
////Assert
}
public void DeleteBookByIdTestMethod()
{
// Arrange
var mockRepository = new Mock <IBookRepository>();
mockRepository.Setup(repository => repository.Get(10))
.Returns(
new Book()
{
Id = 10, Isbn = "1234567", Title = "teste1", Year = 2016
}
);
var controller = new BooksController(mockRepository.Object);
// Act
var result = controller.DeleteBook(10);
// Assert
Assert.IsInstanceOfType(result, typeof(OkResult));
}
public async Task DeleteBook_InvalidId_StatusCode404()
{
//Arrange
var config = new MapperConfiguration(cfg => {
cfg.AddProfile(new AutoMapperProfiles());
});
var repository = new Mock <ILibraryRepository>();
var mapper = config.CreateMapper();
repository.Setup(r => r.GetBook(It.Is <int>(id => id > 3))).ReturnsAsync((Book)null);
var controller = new BooksController(repository.Object, mapper);
//Act
var result = await controller.DeleteBook(4);
var statusCode = result as StatusCodeResult;
//Assert
Assert.NotNull(statusCode);
Assert.Equal(404, statusCode.StatusCode);
}
public async Task DeleteBook_ValidId_StatusCode200()
{
//Arrange
var config = new MapperConfiguration(cfg => {
cfg.AddProfile(new AutoMapperProfiles());
});
var repository = new Mock <ILibraryRepository>();
var mapper = config.CreateMapper();
repository.Setup(r => r.GetBook(It.IsInRange <int>(1, 3, Range.Inclusive))).ReturnsAsync(new Book()
{
Id = 1, Title = "KK", Description = "Testowanie"
});
var controller = new BooksController(repository.Object, mapper);
//Act
var result = await controller.DeleteBook(1);
var statusCode = result as StatusCodeResult;
//Assert
Assert.NotNull(statusCode);
Assert.Equal(200, statusCode.StatusCode);
}
public async Task DeleteBook_BookDoesNotExistInDb_ReturnsUnauthorizedResponse()
{
var result = await _controller.DeleteBook(2);
Assert.That(result, Is.TypeOf <UnauthorizedResult>());
}
