public async Task get_all_books()
{
// Arrange
var repository = BookContextMocker.GetInMemoryBookRepository(nameof(get_all_books));
var controller = new BookController(repository);
// Act
var response = await controller.GetAll() as ObjectResult;
var books = response.Value as List <Book>;
// Assert
Assert.Equal(200, response.StatusCode);
Assert.Equal(5, books.Count);
}
public async Task GetListContainingAllBooks_WhenCalledReturnsAllBooks()
{
//Arrange
var moq = new Mock <IBookService>();
moq.Setup(i => i.GetAllBooks()).ReturnsAsync(DummyBook());
//Act
var controller = new BookController(moq.Object);
var all = await controller.GetListContainingAllBooks();
//Assert
Assert.NotNull(all);
}
public async Task PostABook_WhenNullIsPassed_ReturnsNotFound()
{
//Arrange
var moq = new Mock <IBookService>();
moq.Setup(i => i.CreateBook(null));
//Act
var controller = new BookController(moq.Object);
var result = await controller.PostABook(null);
//Assert
Assert.IsType <NotFoundResult>(result);
}
/// <summary>
/// Menu for handling book data
/// </summary>
public static void BookMenu()
{
bool isBookMenuRunning = true;
while (isBookMenuRunning)
{
Console.Clear();
ASCII.BookMenuASCII();
Console.WriteLine("[1] List all books");
Console.WriteLine("[2] Search books by title");
Console.WriteLine("[3] Search books by author");
Console.WriteLine("[4] Get book information by Id\n");
Console.WriteLine("[5] Go back to main menu");
Console.WriteLine("[6] Quit application");
int.TryParse(Console.ReadLine(), out var bookMenuInput);
switch (bookMenuInput)
{
case 1:
BookController.ListAllBooks();
break;
case 2:
BookController.GetBooksByKeyword();
break;
case 3:
BookController.GetBooksByAuthor();
break;
case 4:
BookController.GetBookById();
break;
case 5:
isBookMenuRunning = false;
break;
case 6:
isBookMenuRunning = false;
MainMenuController.isMainMenuRunning = false;
break;
}
}
}
public void DeleteABook_VerifyOnce()
{
//Arrange
var mock2 = new Mock <IConfiguration>();
string bookname = "Книга";
var mock = new Mock <ILibService>();
mock.Setup(x => x.DeleteABook(bookname, ""));
BookController controller = new BookController(mock.Object, mock2.Object);
//Act
controller.DeleteABook(bookname);
//Assert
mock.Verify(x => x.DeleteABook(bookname, ""), Times.Once);
}
public void Will_Return_One_Review(int reviewId, string title, string body)
{
var fakeReview = A.Fake <Review>();
var bookServiceStub = A.Fake <IBookProvider>();
A.CallTo(() => bookServiceStub.GetBookReview(A <int> ._)).Returns(fakeReview);
var sut = new BookController(bookServiceStub);
var review = sut.GetBookReview(reviewId);
var manager = Fake.GetFakeManager(review);
Assert.Equal(typeof(Review), manager.FakeObjectType);
A.CallTo(() => bookServiceStub.GetBookReview(A <int> ._)).MustHaveHappened();
}
public void TestDeleteBooksNotInStock()
{
Mock <IBookView> bookView = new Mock <IBookView>();
Mock <IBookRepository> bookRepository = new Mock <IBookRepository>();
Mock <IBindingRepository> bindingRepository = new Mock <IBindingRepository>();
var testBooks = GetTestBooksWithInStockTrue(10);
testBooks[9].InStock = false;
bookRepository.Setup(br => br.LoadBooks(It.IsAny <string>())).Returns(testBooks);
var controller = new BookController(bookView.Object, bookRepository.Object, bindingRepository.Object);
controller.LoadBooks("some path");
controller.DeleteBooksNotInStock();
Assert.AreEqual(9, controller.BooksCount);
}
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 void GetBook_Invalid_BookId()
{
//Arrange
int BookId = 0;
//Act
bookServiceMoq.Setup(c => c.GetBook(BookId)).Returns(It.IsAny <Book>());
var controller = new BookController(logger.Object, bookServiceMoq.Object, userService.Object, mailService.Object, taskService.Object);
var result = controller.GetBook(BookId);
var BadRequest = result.Result as BadRequestObjectResult;
// assert
Assert.NotNull(BadRequest);
Assert.Equal(400, BadRequest.StatusCode);
Assert.Equal("Book Id is not Valid", BadRequest.Value);
}
private void btnSearch_Click(object sender, EventArgs e)
{
string username = textBoxSearch.Text;
dynamic user = BookController.GetBook(username);
if (user != null)
{
textBoxBookName.Text = user.Bookname;
}
else
{
textBoxBookName.Text = "";
MessageBox.Show("No Bookname Found");
}
}
public void GivenHttpGetVerb_WhenRequestHasNoParameterAndServiceHasNoBooks_ThenShouldReturnStatusNoContent()
{
// Arrange
var service = new Mock <IBookService>();
service.Setup(s => s.RetrieveByIsbn(It.IsAny <string>()));
var controller = new BookController(service.Object);
// Act
var result = controller.Get() as ResponseMessageResult;
// Assert
service.Verify(s => s.RetrieveAll(), Times.Exactly(1));
result.Should().BeOfType <ResponseMessageResult>();
result.Response.StatusCode.ShouldBeEquivalentTo(204);
}
public void GetBookById_ExistingBook_ReturnsOk()
{
mockService.Setup(s => s.AddBook(It.IsAny <AddBookDto>()))
.Returns(BookTestData.AddBookServiceResponse());
mockService.Setup(s => s.GetBookById(It.IsAny <int>()))
.Returns(BookTestData.GetSingleBookServiceResponse());
BookController bookController = new BookController(mockService.Object);
AddBookDto newBook = BookTestData.AddBookDto();
bookController.AddBook(newBook);
var result = bookController.GetSingleBook(1);
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public void CreateGet()
{
// Arrange
BookController controller = new BookController(
booksServiceMock.Object,
pagesServiceMock.Object,
pageConnectionsServiceMock.Object,
usersServiceMock.Object
);
// Act
ViewResult result = controller.Create() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public void AddBookTest()
{
// Arrange
var repo = new FakeBookRepository();
var bookController = new BookController(repo);
// Act
bookController.AddBook(new Book()
{
Title = "A Tale of Two Cities",
PubDate = DateTime.Parse("1/1/1859")
});
// Assert
Assert.Equal("A Tale of Two Cities",
repo.Books[repo.Books.Count - 1].Title);
}
public void OverdueBooks_Get_Action_Returns_Empty_ViewResult_When_Not_Available()
{
//Arrange
var repository = new FakeBookRepository();
repository.context.BooksBorrowed.Clear();
var modelState = new Mock <IValidationDictionary>();
var mockBookService = new FakeBookService(modelState.Object, repository);
var controller = new BookController(mockBookService);
//Act
var result = controller.ListOverdueBooks() as ViewResult;
//Assert
Assert.AreEqual("Empty", result.ViewName);
}
public void GivenHttpGetVerb_WhenRequestParameterDoesNotIdentifyAnExistingBook_ThenShouldReturnStatusNotFound()
{
// Arrange
string isbn = null;
var service = new Mock <IBookService>();
service.Setup(s => s.RetrieveByIsbn(isbn)).Returns(null as Book);
var controller = new BookController(service.Object);
// Act
var result = controller.Get(isbn);
// Assert
service.Verify(s => s.RetrieveByIsbn(isbn), Times.Exactly(1));
result.Should().BeOfType <NotFoundResult>();
}
public void AddBookTest()
{
// Arrange
var repo = new FakeBookRepository();
var bookController = new BookController(repo);
// Act
bookController.AddBook(new Book()
{
Title = "A Tale of Two Cities"
}, "Charles Dickens");
// Assert
Assert.Equal("A Tale of Two Cities",
repo.Books.Last().Title);
}
public void GivenHttpDeleteVerb_WhenRequestParameterIsInvalidIsbn_ThenShouldReturnStatusNotFound()
{
// Arrange
string isbn = null;
var service = new Mock <IBookService>();
service.Setup(s => s.Delete(isbn));
var controller = new BookController(service.Object);
// Act
var result = controller.Delete(isbn);
// Assert
service.Verify(s => s.Delete(It.IsAny <string>()), Times.Never);
result.Should().BeOfType <NotFoundResult>();
}
public async void AddBookReturnsFase()
{
//Arrange
var mockService = new Mock <IBookService>();
var mockMerdiatR = new Mock <IMediator>();
_bookController = new BookController(mockService.Object, mockMerdiatR.Object);
_bookController.ModelState.AddModelError("Name", "Required");
Book newBook = new Book();
//Act
var isBookAdded = await _bookController.AddNewBook(newBook);
//Assert
Assert.Equal(false, isBookAdded.Value);
}
public void GetAllBooksReturnsListOfBooks()
{
// Arrange
var mockService = new Mock <IBookService>();
var mockMerdiatR = new Mock <IMediator>();
mockService.Setup(s => s.GetAllBooks()).Returns(GetTestBooks());
_bookController = new BookController(mockService.Object, mockMerdiatR.Object);
// Act
ActionResult <List <Book> > books = _bookController.GetAllBooks();
// Assert
Assert.NotEqual(null, books.Value);
Assert.Equal(4, books.Value.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 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 void GetAllBooks_ReturnsOk()
{
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreated();
AddBookDto newBook = GetAddBookDto();
BookService bookService = new BookService(mapper, dbContext);
BookController bookController = new BookController(bookService);
bookController.AddBook(newBook);
var result = bookController.Get();
Assert.That(result, Is.InstanceOf <OkObjectResult>());
}
public void CategoryTest()
{
//Arrange
//Макет репозитория
Mock <IRepository <Book> > mock = new Mock <IRepository <Book> >();
mock.Setup(x => x.GetAll()).Returns(new List <Book> {
new Book {
BookId = 1, CategoryName = "1"
},
new Book {
BookId = 2, CategoryName = "2"
},
new Book {
BookId = 3, CategoryName = "1"
},
new Book {
BookId = 4, CategoryName = "2"
},
new Book {
BookId = 5, CategoryName = "2"
}
});
//создание объекта контроллера
BookController controller = new BookController(mock.Object);
//Макет для получения HttpContext HttpRequest
Mock <HttpRequestBase> request = new Mock <HttpRequestBase>();
Mock <HttpContextBase> httpContext = new Mock <HttpContextBase>();
httpContext.Setup(x => x.Request).Returns(request.Object);
//Создание контекста контроллера
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = httpContext.Object;
//Act
//Вызов метода List
ViewResult view = controller.List("1", 1) as ViewResult;
//Assert
Assert.IsNotNull(view, "Представление получено");
Assert.IsNotNull(view.Model, "Модель получена");
PageListViewModel <Book> model = view.Model as PageListViewModel <Book>;
Assert.AreEqual(2, model.Count);
Assert.AreEqual(1, model[0].BookId);
Assert.AreEqual(3, model[1].BookId);
}
public void Can_Send_Pagination_View_Model()
{
Mock <IBookRepository> mock = new Mock <IBookRepository>();
mock.Setup(b => b.Books).Returns(
new Book[]
{
new Book {
BookId = 1, Author = "Auth1", Category = "Drama", Description = "Desc", Price = 23.3m, Title = "Book1"
},
new Book {
BookId = 2, Author = "Auth2", Category = "Drama", Description = "Desc", Price = 10.2m, Title = "Book2"
},
new Book {
BookId = 3, Author = "Auth3", Category = "Drama", Description = "Desc", Price = 11.8m, Title = "Book3"
},
new Book {
BookId = 4, Author = "Auth4", Category = "Drama", Description = "Desc", Price = 78.2m, Title = "Book4"
},
new Book {
BookId = 5, Author = "Auth5", Category = "Drama", Description = "Desc", Price = 15.0m, Title = "Book5"
},
new Book {
BookId = 6, Author = "Auth6", Category = "Drama", Description = "Desc", Price = 45.1m, Title = "Book6"
},
new Book {
BookId = 7, Author = "Auth7", Category = "Drama", Description = "Desc", Price = 40.4m, Title = "Book7"
},
new Book {
BookId = 8, Author = "Auth8", Category = "Drama", Description = "Desc", Price = 80.5m, Title = "Book8"
}
}
);
BookController controller = new BookController(mock.Object);
controller.pageSize = 3;
BookListViewModel model = controller.List(null, 2).Model as BookListViewModel;
PagingInfo pageInfo = model.pagingInfo;
Assert.AreEqual(pageInfo.CurrentPage, 2);
Assert.AreEqual(pageInfo.ItemsPerPage, 3);
Assert.AreEqual(pageInfo.TotalItems, 8);
Assert.AreEqual(pageInfo.TotalPages, 3);
}
public void Cannot_Save_Invalid_Changes()
{
//Создаем HttpContext и присваиваем cookies для Request и Response
var mockHttpContext = Substitute.For <HttpContextBase>();
//Определяем путь к виртуальному корневому каталогу
mockHttpContext.Request.ApplicationPath.Returns("/");
//Добавление пути файла к виртуальному пути (для использования UrlHelper'a)
mockHttpContext.Response.ApplyAppPathModifier(It.IsAny <string>()).Returns("/mynewVirtualPath/");
// Arrange - создаем Mock-контейнеры для книги и для автора
Mock <IBookContainer> mock = new Mock <IBookContainer>();
//Создаем экземпляр контроллера и присваиваем HttpContext
BookController controller = new BookController(mock.Object);
//Определяем контект контроллера
controller.ControllerContext = new ControllerContext
{
Controller = controller,
HttpContext = mockHttpContext
};
//Инициализируем Url
controller.Url = new UrlHelper(new RequestContext(controller.HttpContext, new RouteData()));
// Создаем новую книгу
Book book = new Book {
Title = "testBook"
};
// Добавляем ошибку уровня модели
controller.ModelState.AddModelError("Error", "Error in model");
// Act - вызываем Post-метод редактирования (сохранения) книги
ActionResult result = controller.EditBook(book);
// Assert
//Проверяем количество вызванных SaveBook для книги
mock.Verify(b => b.SaveBook(It.IsAny <Book>()), Times.Never());
//Проверяем количество вызванных SaveNewAuthor для автора
mock.Verify(auth => auth.SaveNewAuthor(It.IsAny <Author>()), Times.Never());
// Проверяем тип результата
Assert.IsInstanceOfType(result, typeof(PartialViewResult));
}
public void GivenHttpGetVerb_WhenRequestHasNoParameterAndServiceHasBooks_ThenShouldReturnAListOfBooksAndStatusOk()
{
// Arrange
var books = BookStub.CreateListOfSize(SIZE);
var service = new Mock <IBookService>();
service.Setup(s => s.RetrieveAll()).Returns(books);
var controller = new BookController(service.Object);
// Act
var result = controller.Get() as OkNegotiatedContentResult <List <Book> >;
// Assert
service.Verify(s => s.RetrieveAll(), Times.Exactly(1));
result.Should().BeOfType <OkNegotiatedContentResult <List <Book> > >();
result.Content.ShouldAllBeEquivalentTo(books);
}
public void GivenHttpGetVerb_WhenRequestParameterIdentifiesAnExistingBook_ThenShouldReturnStatusOkAndTheBook()
{
// Arrange
var book = BookStub.CreateNew();
var service = new Mock <IBookService>();
service.Setup(s => s.RetrieveByIsbn(book.Isbn)).Returns(book);
var controller = new BookController(service.Object);
// Act
var result = controller.Get(book.Isbn) as OkNegotiatedContentResult <Book>;
// Assert
service.Verify(s => s.RetrieveByIsbn(It.IsAny <string>()), Times.Exactly(1));
result.Should().BeOfType <OkNegotiatedContentResult <Book> >();
result.Content.ShouldBeEquivalentTo(book);
}
public void IndexTest()
{
// Arrange
var repo = new FakeBookRepository();
AddTestBooks(repo);
var bookController = new BookController(repo);
// Act - get a list of books sorted by title in ascending order
var result = (ViewResult)bookController.Index();
var books = (List <Book>)result.Model;
// Assert that book titles are in ascending order.
// This implicitly checks that there are three books in the list as well.
Assert.True(string.Compare(books[0].Title, books[1].Title) < 0 &&
string.Compare(books[1].Title, books[2].Title) < 0);
}
public void TestDeleteConfirmedRedirect()
{
// Arrange
BookController controller = new BookController();
// Act
var bookList = db.BookTbls.ToList();
Random rnd = new Random();
int r = rnd.Next(1, bookList.Count);
var selectedId = bookList[r].Id;
var result = controller.DeleteConfirmed(selectedId) as RedirectToRouteResult;
// Assert
Assert.AreEqual("Index", result.RouteValues["action"].ToString());
}
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 void TestCleanup()
{
_mockService = null;
_controller.Dispose();
_controller = null;
}
public void TestInitialize()
{
MappingConfig.RegisterMappings();
_mockService = MockRepository.GenerateMock<IBookService>();
_controller = new BookController(_mockService);
}
