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");
}
