public async Task post_book_with_correct_data_should_return_status_code_201()
{
//Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(post_book_with_correct_data_should_return_status_code_201));
var mapper = new Mock <IMapper>();
var book = new Book
{
Id = 10,
Title = "Adaptive Code",
Author = "Gary McLean Hall",
Description = "By applying this book’s principles, you can create code" +
" that accommodates new requirements and unforeseen scenarios without significant rewrites.",
Isbn = "978-1509302581",
PublishedAt = new DateTime(2004, 10, 02)
};
mapper.Setup(x => x.Map <Book>(It.IsAny <CreationBookDto>())).Returns(book);
var controller = new BookController(repository, mapper.Object);
//Act
var response = await controller.Post(CorrectDummyCreationBookDto()) as ObjectResult;
var item = response?.Value as Book;
//Assert
response.StatusCode.Should().Be(201);
item.Title.Should().BeEquivalentTo("Adaptive Code");
}
public async Task update_existing_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_existing_id));
var controller = new BookController(repository);
Book newBook = new Book()
{
Title = "New_Book",
Isbn = "6622557799110",
Published = Convert.ToDateTime("2002/11/06")
};
// Act
await controller.Put(3, newBook);
var response = await controller.Get(3) as ObjectResult;
var book = response.Value as Book;
// Assert
Assert.Equal(200, response.StatusCode);
Assert.Equal(newBook.Isbn, book.Isbn);
Assert.Equal(newBook.Published, book.Published);
Assert.Equal(newBook.Title, book.Title);
}
public async Task add_new_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_existing_id));
var controller = new BookController(repository);
int expectedValue = 6;
Book newBook = new Book()
{
Id = 6,
Title = "New Book",
Isbn = "9900119922881",
Published = Convert.ToDateTime("2010/10/10")
};
// Act
await controller.Post(newBook);
var response = await controller.GetAll() as ObjectResult;
var books = response.Value as List <Book>;
// Assert
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedValue, books.Count);
}
public async Task get_book_with_existing_id()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_existing_id));
var controller = new BookController(repository);
var expectedBook = new Book()
{
Id = 1,
Title = "Book_01",
Isbn = "1234567890123",
Published = Convert.ToDateTime("2000/10/25")
};
// Act
var response = await controller.Get(1) as ObjectResult;
var book = response.Value as Book;
// Assert
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedBook.Id, book.Id);
Assert.Equal(expectedBook.Isbn, book.Isbn);
Assert.Equal(expectedBook.Published, book.Published);
Assert.Equal(expectedBook.Title, book.Title);
}
public async Task get_book_with_not_existing_isbn()
{
var repository = BookContextMocker.GetInMemoryBooksRepository(nameof(get_book_with_not_existing_isbn));
var controller = new BookController(repository);
var response = await controller.Get(1234567) as ObjectResult;
var book = response.Value as Book;
Assert.Equal(200, response.StatusCode);
Assert.Equal(null, book);
}
public async Task get_book_with_existing_isbn()
{
var repository = BookContextMocker.GetInMemoryBooksRepository(nameof(get_book_with_existing_isbn));
var controller = new BookController(repository);
var expectedValue = "Harry Potter";
var response = await controller.Get(123456) as ObjectResult;
var book = response.Value as Book;
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedValue, book.Title);
}
public async Task get_all_books()
{
var repository = BookContextMocker.GetInMemoryBooksRepository(nameof(get_all_books));
var controller = new BookController(repository);
var response = await controller.GetAll() as ObjectResult;
var books = response.Value as List <Book>;
Assert.Equal(200, response.StatusCode);
Assert.Equal(5, books.Count);
}
public async Task update_book_with_invalid_book_id_should_return_status_code_404()
{
//Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(post_book_with_exist_isbn_should_return_status_code_409));
var mapper = new Mock <IMapper>();
var controller = new BookController(repository, mapper.Object);
//Act
var response = await controller.Put(222, ExistIsbnDummyCreationBookDto()) as ObjectResult;
//Assert
response.StatusCode.Should().Be(404);
}
public async Task get_book_with_nonexisting_id()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_nonexisting_id));
var controller = new BookController(repository);
var expectedMessage = "The book record couldn't be found.";
// Act
var response = await controller.Get(9999999) as ObjectResult;
// Assert
Assert.Equal(StatusCodes.Status404NotFound, response.StatusCode);
Assert.Equal(expectedMessage, response.Value);
}
public async Task update_book_with_correct_data_should_return_status_code_204()
{
//Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(update_book_with_correct_data_should_return_status_code_204));
var mapper = new Mock <IMapper>();
var controller = new BookController(repository, mapper.Object);
//Act
var response = await controller.Put(2, ExistIsbnDummyCreationBookDto());
//Assert
response.Should().BeOfType <NoContentResult>();
}
public async Task post_book_with_exist_isbn_should_return_status_code_409()
{
//Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(post_book_with_exist_isbn_should_return_status_code_409));
var mapper = new Mock <IMapper>();
var controller = new BookController(repository, mapper.Object);
//Act
var response = await controller.Post(ExistIsbnDummyCreationBookDto());
//Assert
response.Should().BeOfType <ConflictObjectResult>();
}
public async Task delete_book_with_not_existing_id_should_return_status_code_404()
{
//Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(delete_book_with_not_existing_id_should_return_status_code_404));
var mapperMock = new Mock <IMapper>();
var controller = new BookController(repository, mapperMock.Object);
//Act
var response = await controller.Delete(999);
//Assert
response.Should().BeOfType <NotFoundObjectResult>();
}
public async Task post_new_book_with_null()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(post_new_book_with_null));
var controller = new BookController(repository);
Book bookToInsert = null;
var expectedMessage = "Book is null.";
// Act
var response = await controller.Post(bookToInsert) as ObjectResult;
// Assert
Assert.Equal(StatusCodes.Status400BadRequest, response.StatusCode);
Assert.Equal(expectedMessage, response.Value);
}
public async Task get_book_with_existing_id()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_existing_id));
var controller = new BookController(repository);
var expectedTitle = "Zbrodnia i kara";
// Act
var response = await controller.Get(1) as ObjectResult;
var book = response.Value as Book;
// Assert
Assert.Equal(StatusCodes.Status200OK, response.StatusCode);
Assert.Equal(expectedTitle, book.Title);
}
public async Task get_book_by_isbn_with_not_existing_isbn_should_return_status_code_404()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(get_book_by_isbn_with_not_existing_isbn_should_return_status_code_404));
var mapperMock = new Mock <IMapper>();
var controller = new BookController(repository, mapperMock.Object);
var exceptedMessage = "Book with isbn '1111111111111' was not found ";
//Act
var response = await controller.GetByIsbn("1111111111111") as ObjectResult;
//Assert
response.StatusCode.Should().Be(404);
response.Value.Should().BeEquivalentTo(exceptedMessage);
}
public async Task delete_existing_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(delete_existing_book));
var controller = new BookController(repository);
// Act
var response = await controller.Delete(3);
var getBooks = await controller.GetAll() as ObjectResult;
var books = getBooks.Value as List <Book>;
// Assert
Assert.IsType <OkResult>(response);
Assert.Equal(2, books.Count);
}
public async Task get_book_by_id_with_existing_id_should_return_status_code_200()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(get_book_by_id_with_existing_id_should_return_status_code_200));
var mapperMock = new Mock <IMapper>();
var controller = new BookController(repository, mapperMock.Object);
var expectedAuthor = "Jon Skeet";
//Act
var response = await controller.GetById(2) as ObjectResult;
var book = response.Value as Book;
//Assert
response.StatusCode.Should().Be(200);
book.Author.Should().BeEquivalentTo(expectedAuthor);
}
public async Task get_book_by_isbn_with_existing_isbn_should_return_status_code_200()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(get_book_by_isbn_with_existing_isbn_should_return_status_code_200));
var mapperMock = new Mock <IMapper>();
var controller = new BookController(repository, mapperMock.Object);
var expectedTitle = "Clean Architecture: A Craftsman's Guide to Software Structure and Design";
//Act
var response = await controller.GetByIsbn("978-0134494166") as ObjectResult;
var book = response.Value as Book;
//Assert
response.StatusCode.Should().Be(200);
book.Title.Should().BeEquivalentTo(expectedTitle);
}
public async Task search_book_by_phrase_code_should_return_status_code_200()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository
(nameof(search_book_by_phrase_code_should_return_status_code_200));
var mapperMock = new Mock <IMapper>();
var controller = new BookController(repository, mapperMock.Object);
var countOfExceptedBooks = 2;
//Act
var response = await controller.Search("Code") as ObjectResult;
var books = response.Value as IEnumerable <Book>;
//Assert
response.StatusCode.Should().Be(200);
books.Count().Should().Be(countOfExceptedBooks);
}
public async Task update_existing_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(update_existing_book));
var controller = new BookController(repository);
var updatedBook = new Book()
{
Title = "Ender's Game",
Author = "Orson Scott Card",
ISBN = "312159785",
Year = 1985
};
// Act
var response = await controller.Put(1, updatedBook);
// Assert
Assert.IsType <OkResult>(response);
}
public async Task delete_nonexisting_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(delete_nonexisting_book));
var controller = new BookController(repository);
var expectedMessage = "The book to delete record couldn't be found.";
// Act
var response = await controller.Delete(999) as ObjectResult;
var getBooks = await controller.GetAll() as ObjectResult;
var books = getBooks.Value as List <Book>;
// Assert
Assert.Equal(StatusCodes.Status404NotFound, response.StatusCode);
Assert.Equal(expectedMessage, response.Value);
Assert.Equal(3, books.Count);
}
[Fact] async Task delete_existing_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_book_with_existing_id));
var controller = new BookController(repository);
int expectedValue = 3;
// Act
await controller.Delete(1);
await controller.Delete(3);
var response = await controller.GetAll() as ObjectResult;
var books = response.Value as List <Book>;
// Assert
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedValue, books.Count);
}
public async Task update_nonexisting_id()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(update_nonexisting_id));
var controller = new BookController(repository);
var updatedBook = new Book()
{
Title = "Ender's Game",
Author = "Orson Scott Card",
ISBN = "312159785",
Year = 1985
};
var expectedMessage = "The book to update record couldn't be found.";
// Act
var response = await controller.Put(999, updatedBook) as ObjectResult;
// Assert
Assert.Equal(StatusCodes.Status404NotFound, response.StatusCode);
Assert.Equal(expectedMessage, response.Value);
}
public async Task post_new_book_on_existing_id()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(post_new_book_on_existing_id));
var controller = new BookController(repository);
var bookToInsert = new Book()
{
Id = 1,
Title = "Ender's Game",
Author = "Orson Scott Card",
ISBN = "312159785",
Year = 1985
};
var expectedMessage = "Book with specified ID already exists.";
// Act
var response = await controller.Post(bookToInsert) as ObjectResult;
// Assert
Assert.Equal(StatusCodes.Status409Conflict, response.StatusCode);
Assert.Equal(expectedMessage, response.Value);
}
public async Task post_new_book()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(post_new_book));
var controller = new BookController(repository);
var bookToInsert = new Book()
{
Id = 4,
Title = "Ender's Game",
Author = "Orson Scott Card",
ISBN = "312159785",
Year = 1985
};
var expectedTitle = "Ender's Game";
// Act
var response = await controller.Post(bookToInsert) as ObjectResult;
var bookreceived = response.Value as Book;
// Assert
Assert.Equal(StatusCodes.Status201Created, response.StatusCode);
Assert.Equal(expectedTitle, bookreceived.Title);
}
