public async Task GetBook_WhenCalled_RetrievesBookFromDb()
{
var id = 1;
await _controller.GetBook(id);
_repo.Verify(r => r.GetBook(id));
}
public void ReturnsBookTest()
{
var id = 1;
var actionResultTask = booksController.GetBook(id);
var book = actionResultTask.Result.Value;
Assert.AreEqual(id, book.Id);
}
public void GetBook_UnknownIdPassed_ReturnsNotFoundResult()
{
// Act
var notFoundResult = controller.GetBook(4);
// Assert
Assert.IsType <NotFoundResult>(notFoundResult.Result.Result);
}
public void ReturnsBookTest()
{
var id = 1;
var result = BooksController.GetBook(id);
var book = result.Result.Value;
Assert.AreEqual(id, book.Id);
}
public void BookExists_BookIsFound_ReturnsTrue()
{
_bookRepository.Setup(br => br.FindBookAsync(1))
.Returns(Task.FromResult(new Book {
Name = "book", Year = 2019
}));
var result = _booksController.GetBook(1);
Assert.IsInstanceOf <OkObjectResult>(result.Result);
}
public void GetDefaultBookById()
{
Action <int, Func <Book> > assertAction = (bookId, getOriginalBook) => {
var message = Controller.GetBook(bookId).GetMessage();
var book = message.GetContent <Book>();
Assert.AreEqual(getOriginalBook(), book);
};
assertAction(0, () => FakeBooksContext.DefaultBook_0);
assertAction(1, () => FakeBooksContext.DefaultBook_1);
}
public async Task GetBook_ShouldNotFindBook()
{
var controller = new BooksController();
var result = await controller.GetBook(-1);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void TestMethod1()
{
Book book = _booksController.GetBook(1);
//Assert
Assert.AreEqual("1", book.Author);
}
public async Task GetBook_ValidId_ReturnedOkObjectResultNotNullStatusCode200()
{
//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.GetBook(1);
var okObjectResult = result as OkObjectResult;
var model = okObjectResult.Value as BookForDetailedDto;
//Assert
Assert.NotNull(okObjectResult);
Assert.Equal(200, okObjectResult.StatusCode);
Assert.NotNull(model);
}
public void GetBook_ShouldNotFindBook()
{
var controller = new BooksController(GetTestBooks());
var result = controller.GetBook(999);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result.Result, typeof(NotFoundResult));
}
public async Task GetBookAsync_BookExists_Returns_OkObjectResultWithRequestedId()
{
var testBook = new BookGetDto()
{
Id = 1
};
_bookService.Setup(s => s.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(testBook);
var getBookResult = await _booksController.GetBook(It.IsAny <int>());
var okResult = getBookResult.Result as OkObjectResult;
okResult.Should().BeOfType <OkObjectResult>();
var resultBook = okResult.Value as BookGetDto;
resultBook.Id.Should().Be(testBook.Id);
}
public async Task TestGetBook()
{
using (var context = new bookAPIContext(options))
{
BooksController booksController = new BooksController(context, mapper);
ActionResult <IEnumerable <Book> > result = await booksController.GetBook();
Assert.IsNotNull(result); // check not empty word list
Assert.AreEqual(context.Book.Count(), 2);
}
}
public void NotFoundGetBookByIdTestMethod()
{
// Arrange
var mockRepository = new Mock <IBookRepository>();
var controller = new BooksController(mockRepository.Object);
// Act
var result = controller.GetBook(10);
// Assert
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void ReturnGetBook_WhenBookExists_OnCallToGetBook()
{
var bookId = 1;
var bookRepository = A.Fake <IBookRepository>();
A.CallTo(() => bookRepository.BookExists(bookId)).Returns(true);
var controller = new BooksController(bookRepository, null, null, null, null);
var response = controller.GetBook(bookId);
A.CallTo(() => bookRepository.GetBook(bookId)).MustHaveHappened();
}
public void GetBookTest2()
{
int bookId = 2;
var controller = new BooksController(_entityMock.Object);
var result = controller.GetBook(bookId);
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <BookDTO>(objectResult.Value);
Assert.Equal(2, model.Id);
}
public void ReturnBadRequest_WhenBookDoesNotExist_OnCallToGetBook()
{
var bookId = 1;
var bookRepository = A.Fake <IBookRepository>();
A.CallTo(() => bookRepository.BookExists(bookId)).Returns(false);
var controller = new BooksController(bookRepository, null, null, null, null);
var response = controller.GetBook(bookId);
Assert.AreEqual((int)HttpStatusCode.BadRequest, ((BadRequestObjectResult)response.Result).StatusCode);
Assert.AreEqual($"Book with Id {bookId} does not exist.", ((BadRequestObjectResult)response.Result).Value);
}
public void Get_All_Books()
{
var mockBookService = new Mock <IBookService>();
var mockBookAssignmentService = new Mock <IBookAssignmentService>();
mockBookService.Setup(r => r.GetAll()).Returns(GetBooks());
var controller = new BooksController(mockBookService.Object, mockBookAssignmentService.Object);
var books = controller.GetBook();
Assert.Equal(2, books.Count());
mockBookService.Verify(s => s.GetAll(), Times.Once());
}
public async Task GetBook_ShouldReturnBookWithSameID()
{
var context = new TestContext();
context.Books.Add(GetTestBook());
context.Authors.Add(new Author {
AuthorId = 2, Name = "Charles Dickens"
});
var controller = new BooksController(context);
var result = await controller.GetBook(3) as OkNegotiatedContentResult <BookDetailDTO>;
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Content.BookId);
}
public void GetBookTest()
{
//Arrange
var controller = new BooksController
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
//Act
var book = controller.GetBook(1);
//Assert
Assert.IsNotNull(book);
Assert.AreEqual(book.Id, 1, "Returned Id is different to the expected Id.");
}
public async Task GetBook_returns_OkNegotiatedContentResult_if_friends()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var bookId = 20;
var result = await controller.GetBook(bookId) as OkNegotiatedContentResult <BookDTO>;
Assert.IsNotNull(result);
var book = result.Content;
Assert.AreNotEqual(userId, book.OwnerId);
Assert.AreEqual(bookId, book.ID);
}
public void GetBookTest()
{
var controller = new BooksController(_context);
var result = controller.GetBook(_bookDTOs[0].Id);
//Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <VolumeDTO> >(objectResult.Value);
var vols = model.ToList();
for (int i = 0; i < vols.Count; i++)
{
Assert.Equal(_volumeDTOs[i].Id, vols[i].Id);
Assert.Equal(_volumeDTOs[i].BookId, vols[i].BookId);
}
}
public async Task GetApiBookTest()
{
//Arrange
long indexUser = 1;
Mock <InMemoryRepository> mockRepo = new Mock <InMemoryRepository>(MockBehavior.Loose);
mockRepo.Setup(x => x.Books.FindAsync(indexUser))
.ReturnsAsync(new Book()
{
Id = 1, Title = "Book", Author = "Man"
});
BooksController booksController = new BooksController(mockRepo.Object);
//Act
ActionResult <Book> actionResult = await booksController.GetBook(indexUser);
////Assert
Assert.That(actionResult, Is.EqualTo(GetAllBooks()));
}
public async Task GetBook_ShouldReturnBookDetails()
{
// Arrange
var context = new TestBookStoreAPIContext();
context.Books.Add(DemoData.GetDemoBook());
// Act
var controller = new BooksController(context);
var result = await controller.GetBook("id1") as IHttpActionResult;
var contentResult = result as OkNegotiatedContentResult <ApiResponse>;
var book = contentResult.Content.Data as IBookDTO;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(!contentResult.Content.Error);
Assert.AreEqual("id1", book.Id);
}
public void GetBookByIdTestMethod()
{
// Arrange
var mockRepository = new Mock <IBookRepository>();
mockRepository.Setup(repository => repository.Get(1))
.Returns(
new Book()
{
Id = 1, Isbn = "1234567", Title = "teste1", Year = 2016
}
);
var controller = new BooksController(mockRepository.Object);
// Act
var result = controller.GetBook(1) as OkNegotiatedContentResult <Book>;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Content.Id);
}
public void Get_Book_By_Id()
{
var mockBookService = new Mock <IBookService>();
var mockBookAssignmentService = new Mock <IBookAssignmentService>();
mockBookService.Setup(r => r.Get(100)).Returns(new Book()
{
Id = 100
});
var controller = new BooksController(mockBookService.Object, mockBookAssignmentService.Object);
var actionResult = controller.GetBook(100);
var result = Assert.IsType <OkObjectResult>(actionResult);
var book = Assert.IsType <Book>(result.Value);
Assert.Equal(100, book.Id);
mockBookService.Verify(s => s.Get(100), Times.Once());
}
public void TestGetBook()
{
//Arrange
var mockRepository = new Mock <IBookRepository>();
mockRepository.Setup(x => x.GetBook(1))
.Returns(new BookDto {
Title = "Midnight Rain"
});
var controller = new BooksController(mockRepository.Object);
//Act
IHttpActionResult actionResult = controller.GetBook(1);
var contentResult = actionResult as OkNegotiatedContentResult <BookDto>;
//Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual("Midnight Rain", contentResult.Content.Title);
}
public async Task GetBook_InvalidId_ReturnedOkObjectResultIsNotNullStatusCode404()
{
//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.GetBook(4);
var okObjectResult = result as OkObjectResult;
var model = okObjectResult.Value as BookForDetailedDto;
//Assert
Assert.NotNull(okObjectResult);
Assert.Equal(404, okObjectResult.StatusCode);
Assert.Null(model);
}
public async Task GetBook_ShouldReturnCorrectBook()
{
var testProducts = GetTestProducts();
var dbBook = db.Books
.Include(b => b.Author)
.Select(b => new BookDetailDTO()
{
Id = b.Id,
Title = b.Title,
Year = b.Year,
Price = b.Price,
AuthorName = b.Author.Name,
Genre = b.Genre
})
.FirstOrDefault();
var controller = new BooksController();
var result = await controller.GetBook(dbBook.Id) as OkNegotiatedContentResult <BookDetailDTO>;
Assert.IsNotNull(result);
Assert.AreEqual(dbBook.AuthorName, result.Content.AuthorName);
}
public async Task GetBook_returns_WrappedApiError_of_ForbiddenApiError_if_not_friends()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var bookId = 4;
var req = new HttpRequestMessage();
controller.ControllerContext.Request = req;
var result = await controller.GetBook(bookId) as ResponseMessageResult;
Assert.IsNotNull(result);
Assert.AreEqual(HttpStatusCode.Forbidden, result.Response.StatusCode);
var error = await result.Response.Content.ReadAsAsync <WrappedApiError <ForbiddenApiError> >();
Assert.IsNotNull(error);
var innerError = error.Error;
Assert.AreEqual(HttpStatusCode.Forbidden.ToString(), innerError.Code);
}
public async Task GetBook_GivenInvalidId_ExpectBadRequest()
{
var result = await _booksController.GetBook(-1);
Assert.IsInstanceOfType(result, typeof(BadRequestObjectResult));
}
