public async Task EditMethodWhenBookExists_ShouldRedirectToEditPageWithBookModel()
{
var book = new Book();
_bookService.Setup(mock => mock.GetBookByIdAsync(1)).ReturnsAsync(book);
_bookService.Setup((mock => mock.getAuthors())).Returns(Task.FromResult(_authors));
var result = await _booksController.Edit(1);
var viewResult = result as ViewResult;
var model = viewResult.Model as Book;
viewResult.ViewName.Should().Be("Edit");
model.Should().BeEquivalentTo(book);
}
public void BookEditReturnsView()
{
ApplicationUser user = new ApplicationUser()
{
Id = principal.Identity.GetUserId(),
Email = principal.Identity.GetUserName(),
UserName = principal.Identity.GetUserName(),
FirstName = "User",
LastName = "Name"
};
dbContext.ApplicationUsers.Add(user);
Book book = new Book()
{
Id = 1,
User = user,
ApplicationUserId = principal.Identity.GetUserId(),
Title = "Thing Explainer",
Isbn = "9780544668256",
TotalPageCount = 64,
ThumbnailLink = "http://books.google.com/books/content?id=T5xXrgEACAAJ&printsec=frontcover&img=1&zoom=5&source=gbs_api"
};
dbContext.Books.Add(book);
//Act
ViewResult result = controller.Edit(1) as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public async Task Edit_BookWithIdDoesntExist_ReturnsNotFoundView()
{
var book1 = new Book()
{
name = "Higuraszki",
genre = "Horrorek",
year = 2015
};
var book2 = new Book()
{
name = "Wrobiona w magię",
genre = "Fantasy",
year = 2018
};
var service = new Mock <IBookRepository>();
service.Setup(x => x.GetBook(1)).ReturnsAsync(book1);
service.Setup(x => x.GetBook(2)).ReturnsAsync(book2);
var controller = new BooksController(service.Object);
var result = await controller.Edit(2137, book1);
var viewResult = (ViewResult)result;
Assert.AreEqual("NotFound", viewResult.ViewName);
}
public async Task Edit_NewBookInfoValid_ReturnsRedirectToResultAction()
{
var book1 = new Book()
{
name = "Higuraszki",
genre = "Horrorek",
year = 2015
};
var book1Changed = new Book()
{
name = "Higurashi",
genre = "Horror",
year = 2015
};
var service = new Mock <IBookRepository>();
service.Setup(x => x.GetBook(0)).ReturnsAsync(book1);
service.Setup(x => x.BookExists(0)).Returns(true);
var controller = new BooksController(service.Object);
var result = await controller.Edit(0, book1Changed);
Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
}
public async Task Edit_NewBookInfoInvalid_ReturnsObjectWithNewWrongData()
{
var book1 = new Book()
{
name = "Higuraszki",
genre = "Horrorek",
year = 2015
};
var book1Changed = new Book()
{
name = "higurashi",
genre = "horror",
year = 2015
};
var service = new Mock <IBookRepository>();
service.Setup(x => x.GetBook(0)).ReturnsAsync(book1);
service.Setup(x => x.BookExists(0)).Returns(true);
var controller = new BooksController(service.Object);
controller.ModelState.AddModelError("Nope", "Głupotę walnąłeś");
var result = await controller.Edit(0, book1Changed);
var viewResult = (ViewResult)result;
var model = (viewResult).Model as Book;
Assert.AreEqual(book1Changed, model);
}
public async Task Edit_modifies_Book_and_redirects_to_Index_if_valid()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var originalBook = mockDbContext.MockBooks.Object.FirstOrDefault(b => b.ID == 21);
var book = new Book
{
ID = originalBook.ID,
Title = originalBook.Title,
Author = originalBook.Author,
Genre = originalBook.Genre,
ISBN = originalBook.ISBN,
Rating = originalBook.Rating
};
controller.ModelState.Clear();
var result = await controller.Edit(book) as RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.AreEqual(result.RouteValues["action"], "Index");
mockDbContext.Verify(m => m.SaveChangesAsync(), Times.AtLeastOnce());
}
public async Task Edit_BookIdExists_ReturnsSameBook()
{
var book1 = new Book()
{
name = "Higuraszki",
genre = "Horrorek",
year = 2015
};
var book2 = new Book()
{
name = "Wrobiona w magię",
genre = "Fantasy",
year = 2018
};
var service = new Mock <IBookRepository>();
service.Setup(x => x.GetBook(1)).ReturnsAsync(book1);
service.Setup(x => x.GetBook(2)).ReturnsAsync(book2);
var controller = new BooksController(service.Object);
var result = await controller.Edit(1);
var viewResult = (ViewResult)result;
var model = (viewResult).Model as Book;
Assert.AreEqual(book1, model);
}
public async Task Edit_BookExistsWithInvalidData_ReturnsSameModel()
{
var invalidBook = new Book()
{
id = 0,
name = "costam",
genre = "chcialbys",
year = 1999
};
var books = new List <Book>()
{
invalidBook
};
var service = new Mock <IBookRepository>();
service.Setup(x => x.GetBook(0)).ReturnsAsync(invalidBook);
var controller = new BooksController(service.Object);
controller.ModelState.AddModelError("PogieloCie", "TakSieNieRobi");
var result = await controller.Edit(0, invalidBook);
var viewResult = (ViewResult)result;
var model = (viewResult).Model as Book;
Assert.AreEqual(invalidBook, model);
}
public void BooksControllerEdit()
{
var booksController = new BooksController(null);
var result = booksController.Edit(null);
Assert.IsNotNull(result);
}
public void Edit_throws_NotFound_if_not_found()
{
var mockContext = new MockContext();
var controller = new BooksController(mockContext.Object);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Edit(-1));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.NotFound));
}
public void Edit_throws_BadRequest_if_no_Id_passed()
{
var mockContext = new MockContext();
var controller = new BooksController(mockContext.Object);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Edit((int?)null));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.BadRequest));
}
public void EditGetViewLoad()
{
//act
ViewResult result = controller.Edit(101) as ViewResult;
//assert
Assert.AreEqual("Edit", result.ViewName);
}
public void Edit_throws_Forbidden_if_not_mine()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Edit(4));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.Forbidden));
}
public void Edit_ExistingBook_ShowsBookDetails()
{
// Given
var context = new Models.ApplicationDbContext();
var bookController = new BooksController(context);
// When
var result = bookController.Edit(1);
// Assert
}
public void Edit_ExistingBook_ShouldReturnOkObjectResult()
{
var book = new BookToEdit()
{
ISBN = "ABC123", Name = "Clean Code"
};
var result = _controller.Edit("1", book);
result.ISBN.Should().Be(book.ISBN);
}
public void EditNoId()
{
// arrange
int?id = null;
// act
var result = (ViewResult)controller.Edit(id);
// assert
Assert.AreEqual("Error", result.ViewName);
}
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 void Edit_ValidModelState_ReturnsRedirectToIndex()
{
// Arrange
_mockRepo.Setup(repo => repo.GetAll()).Returns(GetTestData());
_mockUnitOfWork.Setup(uow => uow.Books).Returns(_mockRepo.Object);
var book = new BookViewModel()
{
BookId = 1,
Title = "New Title",
Publisher = "ABC Publisher",
Language = "English",
ISBN = "123456789"
};
// Act
var result = _controller.Edit(book);
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", viewResult.ActionName);
}
public async Task EditOnGet_WhenEntityExists_ReturnsViewResult()
{
//Arrange
TestDbSeeder.Initialize(_db);
TestDbSeeder.SeedBooks(_db);
//Act
var bookId = 1;
var result = await _controller.Edit(bookId);
//Assert
var book = await _db.Books.FirstOrDefaultAsync(b => b.Id == bookId);
Assert.NotNull(book);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <BookViewModel>(viewResult.Model);
Assert.Equal(book.Id, model.Id);
Assert.Equal(book.Isbn, model.Isbn);
Assert.Equal(book.Title, model.Title);
Assert.Equal(book.Author, model.Author);
}
public void Edit()
{
// Lets create a valid book objct to add into
Book editedBook = new Book {
Id = 1, BookName = "Book1", Authorname = "John"
};
//Lets create a edit using controller
controller.Edit(editedBook);
List <Book> bookList = _booksRepo.GetAllBooks();
CollectionAssert.Contains(bookList, editedBook);
}
public async Task Edit_returns_ViewResult_if_mine()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var result = await controller.Edit(21) as ViewResult;
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(Book), result.Model);
var model = result.Model as Book;
Assert.AreEqual(model.ID, 21);
}
public void EditBookShouldNotSaveWhenBookIsInvalid()
{
var book = new Book();
var bookInformation = new BookInformation(book);
var mockedRepo = new Mock <Repository>();
var booksController = new BooksController(mockedRepo.Object);
mockedRepo.Setup(repo => repo.Edit(book));
booksController.ModelState.AddModelError("test error", "test exception");
var result = (ViewResult)booksController.Edit(bookInformation);
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["flashError"]);
}
public void TestEditBooks()
{
var mock = new Mock <IBookService>();
int id = 3;
mock.Setup(m => m.GetBookById(It.Is <Int32>(i => i == id))).Returns(books.Find(b => b.BookId == id));
BooksController controller = new BooksController(mock.Object);
var result = controller.Edit(mock.Object.GetBookById(id)) as RedirectToRouteResult;
Assert.AreEqual("Details", result.RouteValues["action"]);
Assert.AreEqual(id, result.RouteValues["id"]);
}
public void ShouldUpdateBookOnEditPost()
{
var editedBook = new Book {
Id = 1, Title = "A book"
};
var editedBookInformation = new BookInformation(editedBook);
var mockedRepo = GetMockedRepo();
mockedRepo.Setup(repo => repo.Edit(editedBook));
var booksController = new BooksController(mockedRepo.Object);
var viewResult = (RedirectToRouteResult)booksController.Edit(editedBookInformation);
mockedRepo.Verify(repo => repo.Edit <Book>(editedBook), Times.Once());
Assert.AreEqual("Updated A book successfully", booksController.TempData["flashSuccess"]);
Assert.AreEqual(1, viewResult.RouteValues["id"]);
}
public void ShouldReturnEditPageOnGetEdit()
{
var book = new Book {
Id = 1, Title = "A book"
};
var mockedRepo = new Mock <Repository>();
mockedRepo.Setup(repo => repo.Get <Book>(book.Id)).Returns(book);
var booksController = new BooksController(mockedRepo.Object);
var editABookView = booksController.Edit(1);
var model = (BookInformation)editABookView.Model;
Assert.AreEqual("PUT", booksController.ViewBag.Method);
Assert.AreEqual("Edit a Book", booksController.ViewBag.Title);
Assert.AreEqual(book.Title, model.Model.Title);
}
public void TestEditMethod()
{
Books books = new Books {
BookId = 1, BookTitle = "Harry Porter", Price = 10
};
//Mock IRepository of books
Mock <IRepository <Books> > mockBooksController = new Mock <IRepository <Books> >();
mockBooksController.Setup(b => b.Update(It.IsAny <Books>())).Callback <Books>(s => books = s);
//Pass in the IRepository books
BooksController booksController = new BooksController(mockBooksController.Object);
var result = booksController.Edit(books) as RedirectToRouteResult;
Assert.AreEqual(result.RouteValues["action"], "Index");
}
public void TestDeleteMethod()
{
Books book = new Books {
BookId = 1, BookTitle = "Harry Porter", Price = 10
};
//Mock IRepository of books
Mock <IRepository <Books> > mockBooksController = new Mock <IRepository <Books> >();
mockBooksController.Setup(b => b.GetByID(It.IsAny <int>())).Returns(book);
//Pass in the IRepository books
BooksController booksController = new BooksController(mockBooksController.Object);
ViewResult result = booksController.Edit(1) as ViewResult;
Assert.AreEqual(book, result.Model);
}
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 Books_Edit_Post()
{
// Arrange
Source source = GetTestSource();
var sources = GetTestSourceSet();
Book book = GetTestBook(source);
var db = new Mock <IPersonalInformationManagerContext>();
db.Setup(e => e.Sources).Returns(sources);
db.Setup(e => e.SetModified(It.IsAny <Book>()));
db.Setup(e => e.SaveChanges()).Returns(1);
BooksController controller = new BooksController(db.Object);
// Act
var result = (RedirectToRouteResult)controller.Edit(book, null);
// Assert
Assert.AreEqual("Index", result.RouteValues["action"]);
}
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");
}
public async Task Edit_returns_Edit_view_if_model_invalid()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var book = mockDbContext.MockBooks.Object.FirstOrDefault(b => b.ID == 43);
book.Title = null;
controller.ModelState.AddModelError("Title", "Title is required");
var result = await controller.Edit(book) as ViewResult;
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(Book), result.Model);
Assert.AreEqual(book, result.Model);
mockDbContext.Verify(m => m.SetModified(It.IsAny <Book>()), Times.Never());
mockDbContext.Verify(m => m.SaveChangesAsync(), Times.Never());
}
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 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 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 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 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");
}
