public void ShouldFilterByGenre() { using (var session = _documentStore.OpenSession()) { var repository = new Repository(session); Enumerable.Range(1, 8).ToList().ForEach(i => repository.Create(new Book { Title = "Book " + i, Language = "Venda", Genre = "Poetry"})); var book1 = new Book { Title = "Book 9", Language = "Zulu", AgeRange = "0-2", Genre = "Picture Books"}; repository.Create(book1); var book2 = new Book { Title = "Book 10", Language = "Zulu", AgeRange = "3-5", Genre = "Fiction" }; repository.Create(book2); session.SaveChanges(); Assert.AreEqual(10, repository.Count<Book>()); var expectedBooks = new List<Book> { book1 }; var booksController = new BooksController(repository); var view = (ViewResult)booksController.Filter(new List<string>(), new List<string>(), new List<string> {"Picture Books"}); var filterInformation = (FilterInformation)view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(1, actualBooks.Count()); Assert.AreEqual(expectedBooks.First().Language, actualBooks.First().Language); Assert.AreEqual(expectedBooks.First().AgeRange, actualBooks.First().AgeRange); Assert.AreEqual(expectedBooks.First().Genre, actualBooks.First().Genre); Assert.AreEqual("Picture Books", filterInformation.Genres.First()); } }
public async Task GivenThatBookWithGivenIdExists_WhenTryingToGetBook_ThenResultContainsBook() { var service = MockRepository.GenerateMock<IModelService<IBook, BookFilter>>(); var book = MockRepository.GenerateMock<IBook>(); book.Stub(x => x.Name).Return("book"); book.Stub(x => x.Identifier).Return(1); book.Stub(x => x.Country).Return("country"); book.Stub(x => x.ISBN).Return("isbn"); book.Stub(x => x.Authors).Return(new List<string> { "author" }); book.Stub(x => x.Released).Return(new DateTime(2000, 1, 1)); book.Stub(x => x.Publisher).Return("publisher"); book.Stub(x => x.MediaType).Return(MediaType.Hardcover); book.Stub(x => x.NumberOfPages).Return(10); service.Stub(x => x.GetAsync(Arg<int>.Is.Equal(1))).Return(Task.FromResult(book)); var mapper = MockRepository.GenerateMock<IModelMapper<IBook, Book>>(); mapper.Stub(x => x.Map(Arg<IBook>.Matches(b => b.Identifier == 1), Arg<UrlHelper>.Is.Anything)) .Return(new Book("someKindOfUrl/1", book.Name, book.ISBN, book.Authors, book.NumberOfPages, book.Publisher, book.Country, AnApiOfIceAndFire.Models.v1.MediaType.Hardcover, book.Released, new List<string>(), new List<string>())); BooksController controller = new BooksController(service, mapper, MockRepository.GenerateMock<IPagingLinksFactory<BookFilter>>()); var result = await controller.Get(1); var okResult = result as OkNegotiatedContentResult<Book>; Assert.IsNotNull(okResult); Assert.AreEqual(book.Name, okResult.Content.Name); Assert.AreEqual("someKindOfUrl/1", okResult.Content.URL); }
public async Task GivenThatBookWithGivenIdDoesNotExist_WhenTryingToGetBook_ThenResultIsOfTypeNotFound() { var service = MockRepository.GenerateMock<IModelService<IBook, BookFilter>>(); service.Stub(x => x.GetAsync(Arg<int>.Is.Anything)).Return(Task.FromResult((IBook)null)); BooksController controller = new BooksController(service, MockRepository.GenerateMock<IModelMapper<IBook, Book>>(), MockRepository.GenerateMock<IPagingLinksFactory<BookFilter>>()); var result = await controller.Get(1); Assert.IsInstanceOfType(result, typeof(NotFoundResult)); }
public void ShouldDeleteBookAndShowListOfBooks() { var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Delete<Book>(1)); var booksController = new BooksController(mockedRepo.Object); var viewResult = booksController.Delete(1); mockedRepo.Verify(repo => repo.Delete<Book>(1)); Assert.AreEqual("Book successfully deleted", booksController.TempData["flash"]); Assert.AreEqual("List", viewResult.RouteValues["action"]); }
public void TestM2() { BooksController book = new BooksController(); var result = book.Create(new Library.Models.Book { Id = 1234, Title = "Tytuł" }); Assert.IsNull(result); }
public void EditBookShouldNotSaveWhenBookIsInvalid() { var book = new Book(); var mockedRepo = new Mock<IRepository>(); var booksController = new BooksController(mockedRepo.Object); mockedRepo.Setup(repo => repo.Edit(book)); booksController.ModelState.AddModelError("test error", "test exception"); var result = (ViewResult)booksController.Edit(book); mockedRepo.Verify(repo => repo.Edit(book), Times.Never(), "failing model validation should prevent updating book"); Assert.AreEqual("There were problems saving this book", booksController.TempData["flash"]); }
public async Task UpdateBookForAuthorAsync_AuthorNotExist_Test() { // Arrange var authorId = Guid.NewGuid(); var bookId = Guid.NewGuid(); var bookForUpdateDto = new BookForUpdateDto { Title = "A Book Title", Description = "Some Description" }; var mockRepo = new Mock <ILibraryRepository>(); mockRepo.Setup(repo => repo.AuthorExistsAsync(authorId)) .ReturnsAsync(false); var mapper = new MapperConfiguration(cfg => cfg.AddProfile(new BookProfile())).CreateMapper(); var controller = new BooksController(mockRepo.Object, mapper); // Act var result = await controller.UpdateBookForAuthorAsync(authorId, bookId, bookForUpdateDto); // Assert Assert.IsType <NotFoundResult>(result); }
public async Task UpdateBookForAuthorAsync_Returns422StatusCode_Test() { // Arrange var authorId = Guid.NewGuid(); var bookId = Guid.NewGuid(); var bookForUpdateDto = new BookForUpdateDto { Title = "The Same", Description = "The Same" }; var mockRepo = new Mock <ILibraryRepository>(); mockRepo.Setup(repo => repo.AuthorExistsAsync(authorId)) .ReturnsAsync(true); var mapper = new MapperConfiguration(cfg => cfg.AddProfile(new BookProfile())).CreateMapper(); var controller = new BooksController(mockRepo.Object, mapper); // Act var result = await controller.UpdateBookForAuthorAsync(authorId, bookId, bookForUpdateDto); // Assert Assert.IsType <UnprocessableEntityObjectResult>(result); }
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 void Books_Create_Post() { // Arrange var sources = GetTestSourceSet(); var books = new InMemoryDbSet <Book> { }; var db = new Mock <IPersonalInformationManagerContext>(); db.Setup(e => e.Sources).Returns(sources); db.Setup(e => e.SaveChanges()).Returns(1); db.Setup(e => e.Books).Returns(books); BooksController controller = new BooksController(db.Object); Source source = GetTestSource(); Book book = GetTestBook(source); // Act var result = (RedirectToRouteResult)controller.Create(book, null); // Assert Assert.AreEqual("Index", result.RouteValues["action"]); }
public void Create_SavesBook_Valid() { // Arrange var db = new FakeLibraryDb(); BooksController controller = new BooksController(db); controller.ControllerContext = new FakeControllerContext(); // Act Book book = new Book(); book.Id = 1; book.Title = "Atuty zguby"; book.Author = "Zelazny, Roger"; book.Isbn = "6814681651"; book.Rate = 5; controller.Create(book); Assert.AreEqual(true, true); }
public async Task Post_ReturnsSuccessfullResponse() { Book book = new Book() { Author = "Test Author 1", Title = "Test Title 1", ISBN = "Test ISBN 1" }; Mock <IBooksRepository> mockRepo = new Mock <IBooksRepository>(); mockRepo.Setup(repo => repo.InsertAsync(book)).ReturnsAsync(book); BooksController controller = new BooksController(mockRepo.Object); IActionResult response = await controller.Create(book); Assert.IsType <CreatedResult>(response); ObjectResult objectResponse = response as ObjectResult; Assert.Equal(201, objectResponse.StatusCode); }
public void Setup() { //This is also a stub, it is only providing the data needed to run the test var bookDbSetStub = new Mock <DbSet <Book> >(); bookDbSetStub.Setup(x => x.FindAsync(1)).ReturnsAsync(new Book() { Id = 1, Isbn = 12345, Title = "Lord of the Rings", Description = "Fantasy" }); bookDbSetStub.Setup(x => x.FindAsync(2)).ReturnsAsync((Book)null); //Inject a stub into another stub contextStub.Setup(x => x.Book).Returns(bookDbSetStub.Object); //Inject the stub booksController = new BooksController(contextStub.Object); }
public void SetUp() { _repo = new Mock <IBookstoreRepository>(); var mapper = new Mock <IMapper>(); var cloudinaryConfig = new Mock <ICloudinaryConfig>(); _controller = new BooksController(_repo.Object, mapper.Object, cloudinaryConfig.Object); _bookParams = new BookParams(); _book = new Book { Id = 1 }; _book.Photos = new List <Photo> { new Photo { Id = 1 } }; _repo.Setup(r => r.GetBook(_book.Id)).Returns(Task.FromResult(_book)); }
public async Task PartiallyUpdateBookForAuthorAsync_Test() { // Arrange var authorId = Guid.Parse("a1da1d8e-1988-4634-b538-a01709477b77"); var bookId = Guid.Parse("1325360c-8253-473a-a20f-55c269c20407"); var patchDoc = new JsonPatchDocument <BookForUpdateDto>(); var bookForUpdateDto = new BookForUpdateDto { Title = "A Book Title", Description = "Some Description" }; var book = GetTestAuthorsData().FirstOrDefault(a => a.Id == authorId) .Books.FirstOrDefault(b => b.Id == bookId); var mockRepo = new Mock <ILibraryRepository>(); mockRepo.Setup(repo => repo.AuthorExistsAsync(authorId)) .Returns(Task.FromResult(true)); mockRepo.Setup(repo => repo.GetBookForAuthorAsync(authorId, bookId)) .ReturnsAsync(book); mockRepo.Setup(repo => repo.UpdateBookForAuthorAsync(book)) .Returns(Task.CompletedTask) .Verifiable(); mockRepo.Setup(repo => repo.SaveChangesAsync()) .ReturnsAsync(true); var mapper = new MapperConfiguration(cfg => cfg.AddProfile(new BookProfile())).CreateMapper(); var controller = new BooksController(mockRepo.Object, mapper); var objectValidator = new Mock <IObjectModelValidator>(); objectValidator.Setup(o => o.Validate(It.IsAny <ActionContext>(), It.IsAny <ValidationStateDictionary>(), It.IsAny <string>(), It.IsAny <Object>())); controller.ObjectValidator = objectValidator.Object; // Act var result = await controller.PartiallyUpdateBookForAuthorAsync(authorId, bookId, patchDoc); // Assert Assert.IsType <NoContentResult>(result); mockRepo.Verify(); }
public void ShouldFilterByLanguage() { using (var session = _documentStore.OpenSession()) { var repository = new Repository(session); Enumerable.Range(1, 8).ToList().ForEach(i => repository.Create(new Book { Title = "Book " + i, Language = "Venda" })); var book1 = new Book { Title = "Book 9", Language = "Zulu" }; repository.Create(book1); var book2 = new Book { Title = "Book 10", Language = "Xhosa" }; repository.Create(book2); session.SaveChanges(); Assert.AreEqual(10, repository.Count <Book>()); var expectedBooks = new List <Book> { book1, book2 }; var booksController = new BooksController(repository); var view = (ViewResult)booksController.Filter(new List <string>() { "Zulu", "Xhosa" }, new List <string>(), new List <string>()); var filterInformation = (FilterInformation)view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(2, actualBooks.Count()); Assert.AreEqual(expectedBooks.First().Language, actualBooks.First().Language); Assert.AreEqual(expectedBooks.Last().Language, actualBooks.Last().Language); Assert.AreEqual(2, filterInformation.Languages.Count()); Assert.AreEqual("Zulu", filterInformation.Languages.First()); Assert.AreEqual("Xhosa", filterInformation.Languages.Last()); } }
public async void TestGetAllWithPagination_without_page_normalisation() { var booksList = new List <Book>(); var booksCount = 20; var expectedPages = 5; var expectedRows = 4; #region nock for (int i = 0; i < booksCount; i++) { booksList.Add(new Book() { Id = i, Title = Guid.NewGuid().ToString() }); } var mockbookService = new Mock <IBookService>(); mockbookService.Setup(repository => repository.GetAll(It.IsAny <int>(), It.IsAny <int>())) .ReturnsAsync((int page, int rows) => booksList.Skip(page * rows).Take(rows)); #endregion var booksController = new BooksController(mockbookService.Object, null, null); for (int page = 0; page < expectedPages; page++) { var result = await booksController.Get(page + 1, expectedRows); Assert.NotNull(result); OkObjectResult okObjectResult = result as OkObjectResult; Assert.NotNull(okObjectResult); Assert.True(okObjectResult.StatusCode.HasValue); Assert.Equal(200, okObjectResult.StatusCode.Value); var books = okObjectResult.Value as IEnumerable <Book>; Assert.Equal(expectedRows, books.Count()); var expectedBooks = booksList.Skip(page * expectedRows).Take(expectedRows); Assert.Equal(expectedBooks, books); } }
public void UpdatedBook_idDoesNotExist() { // Arrange: var controller = new BooksController(_booksService, _reviewsService); var book = new BookViewModel { Title = "test", AuthorFirst = "test", AuthorLast = "test", ISBNNumber = "test", DateOfIssue = new DateTime(1998, 12, 2) }; // Act: var result = controller.UpdateBook(70, book); var notFoundResult = result as NotFoundObjectResult; // Assert: Assert.IsNotNull(result); Assert.AreEqual(404, notFoundResult.StatusCode); }
public void UpdateBookReviewsByUser_InvalidBookId() { // Arrange: var controller = new BooksController(_booksService, _reviewsService); var userId = 1; var bookId = 100; var review = new BookReviewViewModel { Rating = 5, Review = "ok bok", }; // Act: var result = controller.UpdateBookReviewsByUser(userId, bookId, review); var notFoundResult = result as NotFoundObjectResult; // Assert: Assert.IsNotNull(result); Assert.AreEqual(404, notFoundResult.StatusCode); }
public void AddBook() { // Arrange: var controller = new BooksController(_booksService, _reviewsService); var book = new BookViewModel { Title = "test", AuthorFirst = "test", AuthorLast = "test", ISBNNumber = "test", DateOfIssue = new DateTime(1998, 12, 2) }; // Act: var result = controller.AddBook(book); var createdResult = result as CreatedAtRouteResult; // Assert: Assert.IsNotNull(result); Assert.AreEqual(201, createdResult.StatusCode); }
public async Task Index_SearchSingleRecordFromString_ReturnsOneBookWithSameName() { var books = new List <Book>() { new Book { name = "Higurashi", genre = "Horror", year = 2015 }, new Book { name = "Wrobiona w magię", genre = "Fantasy", year = 2018 }, new Book { name = "Akame ga Kill", genre = "Walka", year = 2017 } }; var service = new Mock <IBookRepository>(); service.Setup(x => x.GetBooks("Higurashi")).ReturnsAsync(new List <Book>() { books[0] }); service.Setup(x => x.GetBooks("Wrobiona w magię")).ReturnsAsync(new List <Book>() { books[1] }); service.Setup(x => x.GetBooks("Akame ga Kill")).ReturnsAsync(new List <Book>() { books[2] }); var controller = new BooksController(service.Object); var result = await controller.Index("Higurashi"); var viewResult = (ViewResult)result; var model = (viewResult).Model as List <Book>; Assert.AreEqual(books[0].name, model[0].name); }
public void IndexUnitTest() { // arrange var mockRepo = new Mock <IBookService>(); mockRepo.Setup(n => n.GetAll()).Returns(MockData.GetTestBookItems()); var controller = new BooksController(mockRepo.Object); // act var result = controller.Index(); // assert // Assert.IsType<ViewResult>(result); // var viewResult = result as ViewResult; var viewResult = Assert.IsType <ViewResult>(result); // Assert.IsAssignableFrom<List<Book>>(viewResult.ViewData.Model); // var viewResultBooks = viewResult.ViewData.Model as List<Book>; var viewResultBooks = Assert.IsAssignableFrom <List <Book> >(viewResult.ViewData.Model); Assert.Equal(5, viewResultBooks.Count); }
public void ReturnBookDto_WhenValidUser_CallsUpdateBook() { var updatedBook = new BookDto { Id = 1, UserId = 1, CategoryId = 2, RatingId = 1, Title = "Test", Author = "Test", FinishedOn = DateTime.Now, ImageUrl = "test.png", Year = 2019, PageCount = 111 }; var result = new BookDto { Id = updatedBook.Id }; var userHelper = A.Fake <IUserHelper>(); A.CallTo(() => userHelper.MatchingUsers(A <HttpContext> .Ignored, updatedBook.UserId)).Returns(true); var bookRepository = A.Fake <IBookRepository>(); A.CallTo(() => bookRepository.BookExists(updatedBook.Id)).Returns(true); A.CallTo(() => bookRepository.GetBook(updatedBook.Id)).Returns(result); var updatedBookValidator = new UpdatedBookValidator(); var controller = new BooksController(bookRepository, null, userHelper, null, updatedBookValidator); var response = controller.UpdateBook(updatedBook); A.CallTo(() => bookRepository.Update(A <BookDto> .Ignored)).MustHaveHappened(); Assert.AreEqual(result.Id, response.Value.Id); }
public void Can_Send_Pagination_View_Model() { //Организация (arrange) Mock <IBookRepository> mock = new Mock <IBookRepository>(); mock.Setup(m => m.Books).Returns(new List <Book> { new Book { BookId = 1, Name = "Book1" }, new Book { BookId = 2, Name = "Book2" }, new Book { BookId = 3, Name = "Book3" }, new Book { BookId = 4, Name = "Book4" }, new Book { BookId = 5, Name = "Book5" } }); //Действие (act) BooksController controller = new BooksController(mock.Object); controller.pageSize = 3; //Утверждение (assert) BooksListViewModel result = (BooksListViewModel)controller.List(null, 2).Model; PagingInfo pagingInfo = result.PagingInfo; Assert.AreEqual(pagingInfo.CurrentPage, 2); Assert.AreEqual(pagingInfo.ItemsPerPage, 3); Assert.AreEqual(pagingInfo.TotalItems, 5); Assert.AreEqual(pagingInfo.TotalPages, 2); }
public void BooksControllerListWithSearchQueryShouldPageWithTheQueryText() { var books = new List <Book>(); Enumerable.Range(1, 11).ToList().ForEach(i => books.Add(new Book { Title = "Book 1" })); var mock = new Mock <IFullTextSearch>(); var matched = books; mock.Setup(repo => repo.Search(It.IsAny <string>())).Returns(matched); var booksController = new BooksController(mock.Object); var view = (ViewResult)booksController.Search("Book 1"); var booksInView = ((FilterInformation)view.Model).BookInformations; var actualBooks = booksInView.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(9, actualBooks.Count()); Assert.AreEqual(2, booksInView.PageCount); Assert.AreEqual("Book 1", booksController.ViewBag.SearchQuery); }
public void Can_Paginate() { //Arrange Mock <IBookRepository> mock = new Mock <IBookRepository>(); mock.Setup(m => m.Books).Returns(new List <Book> { new Book { BookId = 1, Name = "Book1" }, new Book { BookId = 1, Name = "Book2" }, new Book { BookId = 1, Name = "Book3" }, new Book { BookId = 1, Name = "Book4" }, new Book { BookId = 1, Name = "Book5" }, }); BooksController controller = new BooksController(mock.Object); controller.pageSize = 3; // Act BooksListViewModel result = (BooksListViewModel)controller.List(null, 2).Model; // Assert List <Book> books = result.Books.ToList(); Assert.IsTrue(books.Count == 2); Assert.AreEqual(books[0].Name, "Book4"); Assert.AreEqual(books[1].Name, "Book5"); }
public void UpdatedBook_validId() { // Arrange: var controller = new BooksController(_booksService, _reviewsService); var book = new BookViewModel { Title = "test", AuthorFirst = "test", AuthorLast = "test", ISBNNumber = "test", DateOfIssue = new DateTime(1998, 12, 2) }; // Act: var result = controller.UpdateBook(1, book); var okResult = result as OkObjectResult; // Assert: Assert.IsNotNull(result); Assert.AreEqual(200, okResult.StatusCode); }
public async Task TestListOrderbyRating(int firstShownRating, int lastShownRating, ReviewOrder reviewOrder) { // Arrange using var dbContext = GetBookSellerContext($"{nameof(ReviewTests)}_{nameof(TestListOrderbyRating)}_{reviewOrder}", 1, 1, 2); var firstReview = dbContext.Review.First(); var lastReview = dbContext.Review.Last(); firstReview.Rating = lastShownRating; lastReview.Rating = firstShownRating; dbContext.SaveChanges(); var controller = new BooksController(dbContext); // Act var response = await controller.ListReviews(1, new ReviewsFilter { OrderBy = reviewOrder }); // Assert Assert.Equal(reviewOrder, response.Value.OrderedBy); Assert.Equal(lastReview.Id, response.Value.Items.First().Id); Assert.Equal(firstReview.Id, response.Value.Items.Last().Id); }
public void ReturnGetUserBooks_WhenUserExists_OnCallToGetCurrentUserBooks() { var userId = 1; var queryOptions = new BookQueryOptions { Page = 0 }; var bookRepository = A.Fake <IBookRepository>(); var userHelper = A.Fake <IUserHelper>(); A.CallTo(() => userHelper.GetUserId(A <HttpContext> .Ignored)).Returns(userId); var userRepository = A.Fake <IUserRepository>(); A.CallTo(() => userRepository.UserExists(A <int> .Ignored)).Returns(true); var controller = new BooksController(bookRepository, userRepository, userHelper, null, null); var response = controller.GetCurrentUserBooks(queryOptions); A.CallTo(() => bookRepository.GetUserBooks(userId, queryOptions)).MustHaveHappened(); }
public void Details() { // Arrange var mock = new Mock <IRepositoryAsynk <Book> >(); var myVar = Task.Run(() => { return(new Book() { Id = 1, Author = "Test", Name = "Test", PublishingYear = DateTime.Now }); }); mock.Setup(a => a.GetAsynk(1)).Returns(myVar); BooksController controller = new BooksController(mock.Object); // Act ViewResult result = controller.Details(1).Result as ViewResult; // Assert Assert.IsNotNull(result); }
public void ShouldListAllBooks() { var books = new List <Book>(); Enumerable.Range(1, 10).ToList().ForEach(i => books.Add(new Book { Id = i })); var mockedRepo = new Mock <Repository>(); mockedRepo.Setup(repo => repo.List <Book>(It.IsAny <int>(), It.IsAny <int>())).Returns(books); var booksController = new BooksController(mockedRepo.Object); var view = booksController.List(); var filterInformation = (FilterInformation)view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.IsTrue(books.SequenceEqual(actualBooks)); Assert.IsFalse(filterInformation.Languages.Any()); mockedRepo.Verify(repo => repo.List <Book>(It.IsAny <int>(), It.IsAny <int>()), Times.Once()); }
public void Shows_Edit_Get() { // Arrange Source source = GetTestSource(); var sources = GetTestSourceSet(); var books = new InMemoryDbSet <Book> { }; var db = new Mock <IPersonalInformationManagerContext>(); db.Setup(e => e.Sources).Returns(sources); db.Setup(e => e.Books).Returns(books); db.Setup(e => e.Books.Find(It.IsAny <int>())).Returns(GetTestBook(source)); BooksController controller = new BooksController(db.Object); // Act ViewResult result = controller.Edit(1) as ViewResult; var model = result.Model as PersonalInformationManager.Models.Book; // Assert Assert.IsNotNull(result); Assert.AreEqual(BOOK_TITLE, model.Title); }
public void ShouldNotCreateBookWhenIsbnAlreadyExists() { const string alreadyExistingIsbn = "12345"; var bookAlreadyInDb = new Book { Id = 1, Isbn = alreadyExistingIsbn }; var bookToCreate = new Book { Isbn = alreadyExistingIsbn }; var mockedRepo = new Mock <Repository>(); mockedRepo.Setup(repo => repo.Search(It.IsAny <Expression <Func <Book, bool> > >())) .Returns(new List <Book> { bookAlreadyInDb }); var booksController = new BooksController(mockedRepo.Object); booksController.Create(new BookInformation(bookToCreate)); mockedRepo.Verify(repo => repo.Create(bookToCreate), Times.Never(), "duplicate ISBN should prevent creating book"); Assert.AreEqual("The ISBN number already exists", booksController.TempData["flashError"]); }
void TestSelectingBookThatDoentExists() { var dbContext = new FakeContext(); dbContext.Books = new[] { new Book() { ID = 1 }, new Book() { ID = 2 }, }.AsQueryable(); booksController = new BooksController(dbContext); var result = booksController.Details(3); Assert.IsType <NotFoundResult>(result); }
public async Task PutApiBookTest() { //Arrange CancellationToken cancellationToken = default; long Id = 1; Book newUser = new Book() { Id = 1, Title = "Book about space2", Author = "NLO" }; Book oldUser = new Book { Title = "Learning Python", Author = "Mark Lutz" }; Mock <InMemoryRepository> mockRepo = new Mock <InMemoryRepository>(MockBehavior.Strict); mockRepo.Setup(x => x.Entry(oldUser)).Verifiable(); BooksController booksController = new BooksController(mockRepo.Object); //Act IActionResult actionResult = await booksController.PutBook(Id, newUser); ////Assert }
void TestSelectingBook() { var dbContext = new FakeContext(); var expectedBook = new Book() { ID = 1 }; dbContext.Books = new[] { expectedBook, new Book() { ID = 2 }, }.AsQueryable(); booksController = new BooksController(dbContext); var result = booksController.Details(1) as ViewResult; Assert.Equal(expectedBook, result.Model as Book); }
public void BooksControllerFilterShouldReturnNothingWhenNoFiltersAreGiven() { using (var session = _documentStore.OpenSession()) { var repository = new Repository(session); var books = new List<Book>(); Enumerable.Range(1, 8) .ToList() .ForEach( i => books.Add(new Book {Title = "Book " + i, Language = "Venda", Genre = "Non-Fiction"})); var book1 = new Book {Title = "Book 9", Language = "Zulu"}; books.Add(book1); var book2 = new Book {Title = "Book 10", Language = "Zulu"}; books.Add(book2); var booksController = new BooksController(repository); var view = (ViewResult) booksController.Filter(null, null, null); var filterInformation = (FilterInformation) view.Model; Assert.IsFalse(filterInformation.BookInformations.Any()); Assert.IsFalse(filterInformation.Languages.Any()); } }
public void BooksControllerFilterByAgeRangeShouldReturnBooksInGivenAgeRange() { var books = new List<Book>(); Enumerable.Range(1, 8).ToList().ForEach(i => books.Add(new Book { Title = "Book " + i, AgeRange = "3-6" })); var book1 = new Book { Title = "Book 9", AgeRange = "0-2" }; books.Add(book1); var book2 = new Book { Title = "Book 10", AgeRange = "0-2" }; books.Add(book2); var mockedRepo = new Mock<Repository>(); var expectedBooks = new List<Book> { book1, book2 }; mockedRepo.Setup(repo => repo.Search<Book>(It.IsAny<Expression<Func<Book, bool>>>(),It.IsAny<int>(), It.IsAny<int>())).Returns(expectedBooks); var booksController = new BooksController(mockedRepo.Object); var view = (ViewResult)booksController.AgeRange("0-2"); var filterInformation = (FilterInformation)view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(2, actualBooks.Count()); Assert.AreEqual("0-2", actualBooks.First().AgeRange); Assert.AreEqual("0-2", actualBooks.Last().AgeRange); mockedRepo.Verify(repo => repo.Search<Book>(It.IsAny<Expression<Func<Book, bool>>>(), It.IsAny<int>(), It.IsAny<int>()), Times.Once()); Assert.AreEqual(1, filterInformation.AgeRanges.Count()); Assert.AreEqual("0-2", filterInformation.AgeRanges.First()); }
public void ShouldReturnCreatePageOnGetCreate() { var booksController = new BooksController(); var createABookView = booksController.Create(); var model = createABookView.Model; Assert.AreEqual("Add a Book", booksController.ViewBag.Title); Assert.IsInstanceOfType(model, typeof(Book)); }
public void ShouldListAllBooks() { var books = new List<Book>(); Enumerable.Range(1, 10).ToList().ForEach(i=>books.Add(new Book{Id = i})); var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.List<Book>()).Returns(books); var booksController = new BooksController(mockedRepo.Object); var view = booksController.List(); var booksInView = (List<Book>) view.Model; mockedRepo.Verify(repo => repo.List<Book>(), Times.Once()); Assert.AreEqual(books, booksInView); }
public void ShouldRedirectToDetailsPageWhenBookIsCreated() { var book = new Book { Title = "The Book" }; var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Create(book)).Returns(new Book { Id = 1, Title = "The Book"}); var booksController = new BooksController(mockedRepo.Object); var viewResult = (RedirectToRouteResult)booksController.Create(book); Assert.IsNotNull(viewResult); Assert.AreEqual("Added The Book successfully", booksController.TempData["flash"]); Assert.AreEqual(1, viewResult.RouteValues["id"]); }
public void ShouldNotUpdateBookOnEditPostIfIsbnIsChangedAndIsDuplicate() { const string isbnForAlreadyExistingBook = "12345"; var bookforEditing = new Book { Id = 1, Title = "A book", Isbn = "11111" }; var bookAlreadyExistingInDb = new Book { Id = 2, Title = "Another book", Isbn = isbnForAlreadyExistingBook}; var mockedRepo = new Mock<Repository>(); mockedRepo.Setup(repo => repo.Search(It.IsAny<Expression<Func<Book, bool>>>())) .Returns(new List<Book> { bookAlreadyExistingInDb, bookforEditing }); bookforEditing.Isbn = isbnForAlreadyExistingBook; var booksController = new BooksController(mockedRepo.Object); booksController.Edit(new BookInformation(bookforEditing)); mockedRepo.Verify(repo => repo.Edit(bookforEditing), Times.Never(), "A book whose ISBN number is edited and duplicates an already existing ISBN number should not be saved to the database"); Assert.AreEqual("The Book Edit was not saved because the provided ISBN number already exists", booksController.TempData["flashError"], "should return the error message in the model"); }
public void BooksControllerListWithSearchQueryShouldPageWithTheQueryText() { var books = new List<Book>(); Enumerable.Range(1, 11).ToList().ForEach(i => books.Add(new Book { Title = "Book 1" })); var mock = new Mock<IFullTextSearch>(); var matched = books; mock.Setup(repo => repo.Search(It.IsAny<string>())).Returns(matched); var booksController = new BooksController(mock.Object); var view = (ViewResult)booksController.Search("Book 1"); var booksInView = ((FilterInformation)view.Model).BookInformations; var actualBooks = booksInView.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(9, actualBooks.Count()); Assert.AreEqual(2, booksInView.PageCount); Assert.AreEqual("Book 1", booksController.ViewBag.SearchQuery); }
public void ShouldUseRepositoryWhenCreatingABook() { var book = new Book(); var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Create(book)).Returns(new Book()); var booksController = new BooksController(mockedRepo.Object); booksController.Create(book); mockedRepo.Verify(repo => repo.Create(book)); }
public void GivenThatModelMapperIsNull_WhenConstructingBooksController_ThenArgumentNullExceptionIsThrown() { var controller = new BooksController(MockRepository.GenerateMock<IModelService<IBook>>(), null); }
public void CreateBookShouldNotSaveWhenBookIsInvalid() { var book = new Book(); var bookInformation = new BookInformation(book); var mockedRepo = new Mock<Repository>(); var booksController = new BooksController(mockedRepo.Object); mockedRepo.Setup(repo => repo.Create(book)).Returns(book); booksController.ModelState.AddModelError("test error","test exception"); booksController.Create(bookInformation); mockedRepo.Verify(repo => repo.Create(book), Times.Never(), "failing model validation should prevent creating book"); Assert.AreEqual("There were problems saving this book", booksController.TempData["flashError"]); }
public void BooksControllerListWithSearchQueryShouldSearchByGivenCondition() { var books = new List<Book>(); Enumerable.Range(1, 9).ToList().ForEach(i => books.Add(new Book { Title = "Book " + i})); books.Add(new Book { Title = "Book 1" }); var mock = new Mock<IFullTextSearch>(); var expectedBooks = new List<Book> {books.First(), books.Last()}; mock.Setup(repo => repo.Search(It.IsAny<string>())).Returns(expectedBooks); var booksController = new BooksController(mock.Object); var view = (ViewResult)booksController.Search("Book 1"); var booksInView = ((FilterInformation)view.Model).BookInformations; var actualBooks = booksInView.Select(bookInformation => bookInformation.Model).ToList(); Assert.AreEqual(true, booksController.ViewBag.HideFilter); Assert.AreEqual(2, actualBooks.Count()); Assert.AreEqual("Book 1", actualBooks.First().Title); Assert.AreEqual("Book 1", actualBooks.Last().Title); mock.Verify(repo => repo.Search(It.IsAny<string>()), Times.Once()); }
public void ShouldCreateBookWhenIsbnIsNull() { var bookAlreadyInDb = new Book { Id = 1, Isbn = null }; var bookToCreate = new Book { Isbn = null }; var mockedRepo = new Mock<Repository>(); mockedRepo.Setup(repo => repo.Search(It.IsAny<Expression<Func<Book, bool>>>())) .Returns(new List<Book> { bookAlreadyInDb }); mockedRepo.Setup(repo => repo.Create(bookToCreate)).Returns(bookToCreate); var booksController = new BooksController(mockedRepo.Object); booksController.Create(new BookInformation(bookToCreate)); mockedRepo.Verify(repo => repo.Create(bookToCreate), Times.Once()); }
public void DetailsShouldThrowA404ExceptionWhenBookIsNotFound() { var repo = new Mock<Repository>(); repo.Setup(it => it.Get<Book>(1)).Returns((Book)null); var booksController = new BooksController(repo.Object); Action getDetails = () => booksController.Details(1); getDetails.ShouldThrow<HttpException>().WithMessage("The requested book could not be found").Where(it => it.GetHttpCode() == 404); }
public void ShouldEditBookWhenIsbnIsNull() { var book = new Book { Id = 1, Isbn = null }; var mockedRepo = new Mock<Repository>(); mockedRepo.Setup(repo => repo.Search(It.IsAny<Expression<Func<Book, bool>>>())) .Returns(new List<Book> { book }); mockedRepo.Setup(repo => repo.Edit(book)); var booksController = new BooksController(mockedRepo.Object); booksController.Edit(new BookInformation(book)); mockedRepo.Verify(repo => repo.Edit(book), Times.Once()); }
public void ShouldListAllBooks() { var books = new List<Book>(); Enumerable.Range(1, 10).ToList().ForEach(i=>books.Add(new Book{Id = i})); var mockedRepo = new Mock<Repository>(); mockedRepo.Setup(repo => repo.List<Book>(It.IsAny<int>(), It.IsAny<int>())).Returns(books); var booksController = new BooksController(mockedRepo.Object); var view = booksController.List(); var filterInformation = (FilterInformation) view.Model; var actualBooks = filterInformation.BookInformations.Select(bookInformation => bookInformation.Model).ToList(); Assert.IsTrue(books.SequenceEqual(actualBooks)); Assert.IsFalse(filterInformation.Languages.Any()); mockedRepo.Verify(repo => repo.List<Book>(It.IsAny<int>(), It.IsAny<int>()), Times.Once()); }
public void ShouldNotCreateBookWhenIsbnAlreadyExists() { const string alreadyExistingIsbn = "12345"; var bookAlreadyInDb = new Book { Id = 1, Isbn = alreadyExistingIsbn }; var bookToCreate = new Book { Isbn = alreadyExistingIsbn }; var mockedRepo = new Mock<Repository>(); mockedRepo.Setup(repo => repo.Search(It.IsAny<Expression<Func<Book, bool>>>())) .Returns(new List<Book> { bookAlreadyInDb }); var booksController = new BooksController(mockedRepo.Object); booksController.Create(new BookInformation(bookToCreate)); mockedRepo.Verify(repo => repo.Create(bookToCreate), Times.Never(), "duplicate ISBN should prevent creating book"); Assert.AreEqual("The ISBN number already exists", booksController.TempData["flashError"]); }
public void ShouldReturnEditPageOnGetEdit() { var book = new Book { Id = 1, Title = "A book" }; var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Get<Book>(book.Id)).Returns(book); var booksController = new BooksController(mockedRepo.Object); var editABookView = booksController.Edit(1); var model = (Book)editABookView.Model; Assert.AreEqual("Edit a Book", booksController.ViewBag.Title); Assert.AreEqual(book.Title, model.Title); }
public async Task GivenThatNoBooksExists_WhenTryingTogetAll_ThenResultContainsNoBooks() { var service = MockRepository.GenerateMock<IModelService<IBook, BookFilter>>(); var bookPagedList = MockRepository.GenerateMock<IPagedList<IBook>>(); service.Stub(x => x.GetPaginatedAsync(0, 0, null)).IgnoreArguments() .Return(Task.FromResult((IPagedList<IBook>)new PagedList<IBook>(Enumerable.Empty<IBook>().AsQueryable(), 1, 1))); var mapper = MockRepository.GenerateMock<IModelMapper<IBook, Book>>(); mapper.Stub(x => x.Map(null, null)).IgnoreArguments().Return(null); var linksFactory = MockRepository.GenerateMock<IPagingLinksFactory<BookFilter>>(); linksFactory.Stub(x => x.Create(bookPagedList, null, new BookFilter())).IgnoreArguments().Return(new[] { new Link(new Uri("https://localhost.com")) }); var controller = new BooksController(service, mapper, linksFactory) { Configuration = new HttpConfiguration(), Request = new HttpRequestMessage(HttpMethod.Get, new Uri("https://localhost.com/something")), }; IEnumerable<Book> books; var result = await controller.Get(); result.TryGetContentValue(out books); Assert.AreEqual(HttpStatusCode.OK, result.StatusCode); Assert.AreEqual(0, books.Count()); }
public void ShouldUpdateBookOnEditPost() { var editedBook = new Book { Id = 1, Title = "A book" }; var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Edit(editedBook)); var booksController = new BooksController(mockedRepo.Object); var viewResult = (RedirectToRouteResult)booksController.Edit(editedBook); mockedRepo.Verify(repo => repo.Edit<Book>(editedBook), Times.Once()); Assert.AreEqual("Updated A book successfully", booksController.TempData["flash"]); Assert.AreEqual(1, viewResult.RouteValues["id"]); }
public async Task GivenThatOneBookExists_WhenTryingToGetAll_ThenResultContainsCorrectBook() { var book = CreateMockedBook(1); var service = MockRepository.GenerateMock<IModelService<IBook, BookFilter>>(); var pagedList = new PagedList<IBook>(new List<IBook> { book }.AsQueryable(), 1, 1); service.Stub(x => x.GetPaginatedAsync(0, 0)).IgnoreArguments() .Return(Task.FromResult((IPagedList<IBook>)pagedList)); var linksFactory = MockRepository.GenerateMock<IPagingLinksFactory<BookFilter>>(); linksFactory.Stub(x => x.Create(pagedList, null, new BookFilter())).IgnoreArguments().Return(new[] { new Link(new Uri("https://localhost.com")) }); var mapper = new BookMapper(new MediaTypeMapper()); var controller = new BooksController(service, mapper, linksFactory) { Configuration = new HttpConfiguration(), Request = new HttpRequestMessage(HttpMethod.Get, new Uri("http://localhost.com")), Url = Helper.CreateUrlHelper("http://localhost.com") }; IEnumerable<Book> books; var result = await controller.Get(); result.TryGetContentValue(out books); Assert.AreEqual(1, books.Count()); }
public async Task GivenThatNoBooksExists_WhenTryingTogetAll_ThenResultContainsNoBooks() { var service = MockRepository.GenerateMock<IModelService<IBook>>(); service.Stub(x => x.GetPaginatedAsync(Arg<int>.Is.Anything, Arg<int>.Is.Anything)) .Return(Task.FromResult((IPagedList<IBook>)new PagedList<IBook>(Enumerable.Empty<IBook>().AsQueryable(), 1, 1))); var mapper = MockRepository.GenerateMock<IModelMapper<IBook, Book>>(); var urlHelper = MockRepository.GenerateMock<UrlHelper>(); urlHelper.Stub(x => x.Link(Arg<string>.Is.Anything, Arg<object>.Is.Anything)).Return("https://localhost.com"); var controller = new BooksController(service, mapper) { Configuration = new HttpConfiguration(), Url = urlHelper, Request = new HttpRequestMessage(HttpMethod.Get, new Uri("https://localhost.com/something")) }; IEnumerable<Book> books; var result = await controller.Get(); result.TryGetContentValue(out books); Assert.AreEqual(HttpStatusCode.OK, result.StatusCode); Assert.AreEqual(0, books.Count()); }
public void BooksControllerListWithSearchQueryShouldRedirectToDetailsWhenThereIsOnlyOneResult() { var mock = new Mock<IFullTextSearch>(); var expectedBooks = new List<Book> { new Book {Id=1, Title = "Book 1" } }; mock.Setup(repo => repo.Search(It.IsAny<string>())).Returns(expectedBooks); var booksController = new BooksController(mock.Object); var viewResult = (RedirectToRouteResult)booksController.Search("Book 1"); Assert.AreEqual(1, viewResult.RouteValues["id"]); }
public void ShouldDisplayBookDetails() { var book = new Book {Id = 1, Title = "A book"}; var mockedRepo = new Mock<IRepository>(); mockedRepo.Setup(repo => repo.Get<Book>(book.Id)).Returns(book); var booksController = new BooksController(mockedRepo.Object); var view = booksController.Details(1); var bookInView = (Book) view.Model; Assert.IsInstanceOfType(view, typeof(ViewResult)); mockedRepo.Verify(repo => repo.Get<Book>(book.Id), Times.Once()); Assert.AreEqual(book, bookInView); }
public void ShouldUpdateBookOnEditPostWithIsbnUnchanged() { var bookforEditing = new Book { Id = 1, Title = "A book", Isbn = "11111" }; var mockedRepo = new Mock<Repository>(); var existingBooks = new List<Book> {bookforEditing}; mockedRepo.Setup(repo => repo.Search(It.IsAny<Expression<Func<Book, bool>>>())) .Returns((Expression<Func<Book, bool>> predicate) => existingBooks.Where(predicate.Compile()).ToList()); bookforEditing.Title = "Changed Book Name"; var booksController = new BooksController(mockedRepo.Object); booksController.Edit(new BookInformation(bookforEditing)); mockedRepo.Verify(repo => repo.Edit(bookforEditing), Times.Once(), "Book Should be Edited"); }