public void DetailsUnitTest_BW(string validGuid, string invalidGuid)
{
//arrange
var mockRepo = new Mock <IBookService>();
var validItemGuid = new Guid(validGuid);
mockRepo.Setup(n => n.GetById(validItemGuid)).Returns(MockData.GetTestBookItems().FirstOrDefault(x => x.Id == validItemGuid));
var controller = new BooksController(mockRepo.Object);
//act
var result = controller.Details(validItemGuid);
//assert
var viewResult = Assert.IsType <ViewResult>(result);
var viewResultValue = Assert.IsAssignableFrom <Book>(viewResult.ViewData.Model);
Assert.Equal("Managing Oneself", viewResultValue.Title);
Assert.Equal("Peter Drucker", viewResultValue.Author);
Assert.Equal(validItemGuid, viewResultValue.Id);
//arrange
var invalidItemGuid = new Guid(invalidGuid);
mockRepo.Setup(n => n.GetById(invalidItemGuid)).Returns(MockData.GetTestBookItems().FirstOrDefault(x => x.Id == invalidItemGuid));
//act
var notFoundResult = controller.Details(invalidItemGuid);
//assert
Assert.IsType <NotFoundResult>(notFoundResult);
}
public void Details_passes_correct_book_and_searchSortPageParams_to_view()
{
// Arrange
string searchString = "H3J";
string sortCol = "name";
string nextOrder = SearchSortPageViewModel.SORT_ORDER_ASC;
string currentOrder = SearchSortPageViewModel.SORT_ORDER_ASC;
int page = 1;
int pageSize = 5;
int id = 1;
SearchSortPageViewModel sspVM = new SearchSortPageViewModel(searchString, sortCol, currentOrder, nextOrder, page, pageSize);
RecordViewModel rVM = new RecordViewModel(sspVM, id);
// Act
ViewResult result = controller.Details(rVM) as ViewResult;
DetailsViewModel detailsVM = (DetailsViewModel)result.ViewData.Model;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(id, detailsVM.Book.ID);
Assert.AreEqual("BBB", detailsVM.Book.Name);
Assert.IsNotNull(detailsVM.SearchSortPageParams);
Assert.AreEqual(searchString, detailsVM.SearchSortPageParams.SearchString);
Assert.AreEqual(sortCol, detailsVM.SearchSortPageParams.SortCol);
Assert.AreEqual(nextOrder, detailsVM.SearchSortPageParams.NextOrder);
Assert.AreEqual(page, detailsVM.SearchSortPageParams.Page);
Assert.AreEqual(pageSize, detailsVM.SearchSortPageParams.PageSize);
}
public void DetailsViewLoad()
{
//act
ViewResult result = controller.Details(101) as ViewResult;
//assert
Assert.AreEqual("Details", result.ViewName);
}
public void DetailsNoId()
{
// act
var result = (ViewResult)controller.Details(null);
// assert
Assert.AreEqual("Error", result.ViewName);
}
public void Can_Get_Item_Details()
{
repository.Add(someBook);
var result = controller.Details(someBook.Id);
Assert.That(result, Is.InstanceOf <ViewResult>());
var vResult = (ViewResult)result;
Assert.That(vResult.Model, Is.InstanceOf <ViewBookModel>());
Assert.That(((ViewBookModel)vResult.Model).Id, Is.EqualTo(someBook.Id));
}
public void Details_HasCorrectModelType_BookList()
{
//Arrange
BooksController controller = new BooksController();
IActionResult actionResult = controller.Details(1);
ViewResult detailView = controller.Details(1) as ViewResult;
//Act
var result = detailView.ViewData.Model;
//Assert
Assert.IsInstanceOfType(result, typeof(Dictionary <string, object>));
}
public void DetailsTest()
{
var controller = new BooksController();
var result = controller.Details(2) as ViewResult;
Assert.AreEqual("Details", result.ViewName);
}
public async Task Details_BookDoesntExist_ReturnsNotFoundView()
{
var book1 = new Book()
{
name = "Higurashi",
genre = "Horror",
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.Details(1555);
var viewResult = (ViewResult)result;
Assert.AreEqual("NotFound", viewResult.ViewName);
}
public void BookDetailsReturnsView()
{
//Arrange
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.Details(1) as ViewResult;
//Assert
Assert.IsNotNull(result);
//Assert.AreEqual(1,1);
}
public async Task Details_BookExists_ReturnsBook()
{
var book1 = new Book()
{
name = "Higurashi",
genre = "Horror",
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.Details(1);
var viewResult = (ViewResult)result;
var model = (viewResult).Model as Book;
Assert.AreEqual(book1, model);
}
public void Details_ValidId_ReturnsDetailsAndIssuer()
{
// Arrange
var bookId = 1;
_mockRepo.Setup(repo => repo.GetSingleWithAuthorsSubjects(bookId)).Returns(GetTestData().FirstOrDefault());
_mockUnitOfWork.Setup(uow => uow.Books).Returns(_mockRepo.Object);
// Act
var result = _controller.Details(bookId);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <BookViewModel>(viewResult.Model);
Assert.NotNull(model.Issue);
}
public void TestDetailsViewData()
{
var controller = new BooksController();
var result = controller.Details(1) as ViewResult;
var book = (Book)result.ViewData.Model;
Assert.AreEqual("0061031321", book.ISBN);
}
public void BooksControllerDetails()
{
var booksController = new BooksController(null);
var result = booksController.Details(null);
Assert.IsNotNull(result);
}
void TestGettingDetailsFromNull()
{
var dbContext = new FakeContext();
booksController = new BooksController(dbContext);
var result = booksController.Details(null);
Assert.IsType <NotFoundResult>(result);
}
public void Details_throws_BadRequest_if_no_Id_passed()
{
var mockContext = new MockContext();
var controller = new BooksController(mockContext.Object);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Details(null));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.BadRequest));
}
public async Task RedirectToBookDetails_ShouldReturnViewWithReturnedBook()
{
var book1 = new Book()
{
Title = "TEST1"
};
_bookService.Setup((mock => mock.getAuthors())).Returns(Task.FromResult(_authors));
_bookService.Setup(mock => mock.GetBookByIdAsync(1)).ReturnsAsync(book1);
var result = await _booksController.Details(1);
var viewResult = result as ViewResult;
var model = viewResult.Model as Book;
model.Should().Be(book1);
viewResult.ViewName.Should().Be("Details");
}
public void Details_throws_NotFound_if_not_found()
{
var mockContext = new MockContext();
var controller = new BooksController(mockContext.Object);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Details(-1));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.NotFound));
}
public void Details_throws_Forbidden_if_not_friends()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var httpException = Assert.ThrowsAsync <HttpException>(async() => await controller.Details(4));
Assert.That(httpException.GetHttpCode(), Is.EqualTo((int)HttpStatusCode.Forbidden));
}
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 Details_ReturnsCorrectView_True()
{
//Arrange
BooksController controller = new BooksController();
//Act
ActionResult detailView = controller.Details(1);
//Assert
Assert.IsInstanceOfType(detailView, typeof(ViewResult));
}
public async Task DetailsOnGet_WhenEntityExists_ReturnsViewResult()
{
//Arrange
TestDbSeeder.Initialize(_db);
TestDbSeeder.SeedBooks(_db);
//Act
var bookId = 1;
var result = await _controller.Details(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 async Task Details_returns_ViewResult_if_mine()
{
var userId = "foxyboots9-guid";
var mockDbContext = new MockContext();
var controller = new BooksController(mockDbContext.Object, () => userId);
var result = await controller.Details(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 TestDetailsMethod()
{
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.Details(1) as ViewResult;
Assert.AreEqual(book, result.Model);
}
public void Books_Details()
{
// Arrange
Source source = GetTestSource();
var books = GetTestBookSet(source);
var db = new Mock <IPersonalInformationManagerContext>();
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.Details(1) as ViewResult;
var model = result.Model as PersonalInformationManager.Models.Book;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(BOOK_TITLE, model.Title);
}
public void ShouldDisplayBookDetails()
{
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 view = booksController.Details(1);
var bookInView = (BookInformation)view.Model;
Assert.IsInstanceOfType(view, typeof(ViewResult));
mockedRepo.Verify(repo => repo.Get <Book>(book.Id), Times.Once());
Assert.AreEqual(book, bookInView.Model);
Assert.AreEqual("A book", booksController.ViewBag.Title);
}
public void TestDetailView()
{
//var list = new List<string>
//{
// "test1", "test2"
//};
//var book = new Book
//{
// Id = "testId",
// BookName = "testBookName",
// Categories = list,
// Publishers = list,
// Authors = list,
// ReleaseDay = DateTime.Now
//};
var controller = new BooksController();
var result = controller.Details("testId") as ViewResult;
Assert.AreEqual("Details", result.ViewName);
}
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);
}
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);
}
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 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 ShouldReturnDetailsPageOnGetDetails()
{
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 detailsOfABookView = booksController.Details(1);
var model = (Book) detailsOfABookView.Model;
Assert.AreEqual("A book", booksController.ViewBag.Title);
Assert.AreEqual(book.Title, model.Title);
}
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 Details()
{
ViewResult result = controller.Details(1) as ViewResult;
Assert.AreEqual(result.Model, book1);
}
