public async Task TestCreateBook_ReturnsCreatedStatusCode() { //Arrange mockService.Setup(x => x.Book.CreateAsync(It.IsAny <IBooks>())).ReturnsAsync(true); mockService.Setup(y => y.Author.CreateAsync(It.IsAny <Author>())).ReturnsAsync(() => new Author { Id = 1, FirstName = "J.R.R", LastName = "Tolkien" }); mockService.Setup(e => e.Category.GetCategoryByName(It.IsAny <string>())).ReturnsAsync(() => new Category { Id = 1, Name = "Adventure" }); //Act var response = await bookController.Create(createBookByRequest); //Assert mockService.Verify(x => x.Author.CreateAsync(It.IsAny <Author>()), Times.Once()); mockService.Verify(x => x.Category.GetCategoryByName(It.IsAny <string>()), Times.Once()); response.Should().BeOfType <JsonResult <BookResponse> >(); }
public void CreateViewLoads() { // act var result = (ViewResult)controller.Create(); // assert Assert.AreEqual("Create", result.ViewName); }
public void CreateGetViewLoad() { //act ViewResult result = controller.Create() as ViewResult; //assert Assert.AreEqual("Create", result.ViewName); }
public async Task CreateFunctionWithoutArgument_ShouldRedirectToCreatePage() { _bookService.Setup((mock => mock.getAuthors())).Returns(Task.FromResult(_authors)); var result = await _booksController.Create() as ViewResult; result.ViewData.Keys.Count.Should().Be(1); result.ViewData.Should().NotBeNull(); result.ViewName.Should().Be("Create"); }
public void Can_Start_Creating_New_Item() { var result = controller.Create(); Assert.That(result, Is.InstanceOf <ViewResult>()); var vResult = (ViewResult)result; Assert.That(vResult.Model, Is.InstanceOf <EditBookModel>()); Assert.That(((EditBookModel)vResult.Model).Id, Is.EqualTo(0)); }
public void CreateOnGet_WhenEnteringEmptyForm_ReturnsViewResult() { //Arrange & Act var result = _controller.Create(); //Assert var viewResult = Assert.IsType <ViewResult>(result); Assert.Null(viewResult.Model); }
public void CreateMethodsAlwaysReturnsCreateView() { //Arrange //Act ViewResult result = controller.Create() as ViewResult; //Assert Assert.IsNotNull(result); }
public async Task Create_InvalidPayload_ReturnsBadRequestResult() { // Act _bookServiceMock.Setup(x => x.CreateAsync(It.IsAny <Book>())).ReturnsAsync((Book)null); var response = await _booksController.Create(new AddBookRequest()); // Assert response.Result.Should().BeOfType <BadRequestResult>(); VerifyLinkGeneratorHasNeverBeenCalled(); }
public void Create_with_no_args_returns_selectlist_of_books() { // 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; SearchSortPageViewModel sspVM = new SearchSortPageViewModel(searchString, sortCol, currentOrder, nextOrder, page, pageSize); // Act //var result = controller.Create(); ViewResult result = controller.Create(sspVM) as ViewResult; // Assert Assert.IsNotNull(result); Assert.IsInstanceOf <SelectList>(result.ViewBag.PublisherID); //Assert.AreEqual(result.ViewBag.PublisherID.Count(), 4); //Assert.AreEqual(result.ViewBag.PublisherID.Items.Count(), 4); //Assert.IsInstanceOf<Publisher>(result.ViewBag.PublisherID.Items); // How can I tell if the items in the selectList are publishers? foreach (var item in result.ViewBag.PublisherID.Items) { Console.WriteLine(item); } //Console.WriteLine(typeof(result.ViewBag.PublisherID.Items)); }
public async Task Create_adds_Book_and_redirects_to_Index_if_valid() { var userId = "foxyboots9-guid"; var mockDbContext = new MockContext(); var controller = new BooksController(mockDbContext.Object, () => userId); var book = new Book() { ID = 59, ISBN = "1234567890", Title = "Harry Potter and the Half-Blood Prince", Author = "J. K. Rowling", Rating = 4, Genre = "Children" }; controller.ModelState.Clear(); var result = await controller.Create(book) as RedirectToRouteResult; Assert.IsNotNull(result); Assert.AreEqual(result.RouteValues["action"], "Index"); mockDbContext.MockBooks.Verify(m => m.Add(It.IsAny <Book>()), Times.Once()); mockDbContext.Verify(m => m.SaveChangesAsync(), Times.AtLeastOnce()); }
public void Test_Create_ReturnsSuccessPartialView_WhenRequestIsAjax() { //ARRANGE var mockRequest = new Mock <HttpRequestBase>(); //Request - 1 mockRequest.Setup(x => x["X-Requested-With"]).Returns("XMLHttpRequest"); var mockHttpContext = new Mock <HttpContextBase>(); //Request inside context - 2 mockHttpContext.SetupGet(x => x.Request).Returns(mockRequest.Object); var controllerContext = new ControllerContext(); //Context inside controller - 3 controllerContext.HttpContext = mockHttpContext.Object; BooksController classUnderTest = new BooksController(); //Controller Context inside of controller - 4 classUnderTest.ControllerContext = controllerContext; Mock <Book> mockBook = new Mock <Book>(); //Need to mock DB for this test to work //ACT var actual = classUnderTest.Create(mockBook.Object) as PartialViewResult; //ASSERT Assert.AreEqual("_Success", actual.ViewName); }
public void Test_Create_ReturnsSuccessPartialView_WhenRequestIsAjax() { //Arrange var mockRequest = new Mock <HttpRequestBase>(); mockRequest.Setup(x => x ["X-Requested-With"]).Returns("XMLHttpRequest"); //think its ajax and make a http request var mockHttpContext = new Mock <HttpContextBase>(); mockHttpContext.SetupGet(x => x.Request).Returns(mockRequest.Object); //give it a context var controllerContext = new ControllerContext(); controllerContext.HttpContext = mockHttpContext.Object; //put that inside a controller context BooksController classUnderTest = new BooksController(); classUnderTest.ControllerContext = controllerContext; //put that in a controller //Above is wrapping it all up to make it think its ajax Mock <Book> mockBook = new Mock <Book>(); //Need to mock DB, that's why its failing XD //Act var actual = classUnderTest.Create() as PartialViewResult; //Assert Assert.AreEqual("_success", actual.ViewName); }
public async Task Create_returns_Create_view_if_model_invalid() { var userId = "foxyboots9-guid"; var mockDbContext = new MockContext(); var controller = new BooksController(mockDbContext.Object, () => userId); var book = new Book() { ID = 159, ISBN = "1234567890", Author = "J. K. Rowling", Rating = 4, Genre = "Children" }; controller.ModelState.AddModelError("Title", "Title is required"); var result = await controller.Create(book) as ViewResult; Assert.IsNotNull(result); Assert.IsInstanceOf(typeof(Book), result.Model); Assert.AreEqual(book, result.Model); mockDbContext.MockBooks.Verify(m => m.Add(It.IsAny <Book>()), Times.Never()); mockDbContext.Verify(m => m.SaveChangesAsync(), Times.Never()); }
public void Create_WhenCalled_ShouldAddNewBook() { // Given Clock.Freeze(); var viewModel = new BookFormViewModel { Id = 1, Name = "Selcen's test book", Pages = "10", Date = Clock.Now().Date.ToString("dd/MM/yyyy"), Reader = 1, Comments = "-" }; var context = GetDbContext(); var controller = new BooksController(context); // When var result = controller.Create(viewModel); // Assert Assert.Equal(1, context.Books.Count()); var book = context.Books.First(); Assert.Equal(1, book.Id); Assert.Equal("10", book.Pages); Assert.Equal(Clock.Now(), book.DateTime); Assert.Equal(1, book.ReaderId); Assert.Equal("-", book.Comments); Assert.Equal("Home", result.ControllerName); Assert.Equal("Index", result.ActionName); }
public void BooksControllerCreate() { var booksController = new BooksController(null); var result = booksController.Create(); Assert.IsNotNull(result); }
public void AddBook_ReturnsViewResult() { var service = new Mock <IBookRepository>(); var controller = new BooksController(service.Object); var result = controller.Create(); Assert.IsInstanceOfType(result, typeof(ViewResult)); }
public async Task RedirectionAfterCreatingBook() { var book = new Book(); var bookRepository = new FakeBookRepository(); var controller = new BooksController(bookRepository); var result = await controller.Create(book); Assert.IsInstanceOfType(result, typeof(RedirectToActionResult)); }
public void TestAddingBook() { Book to_add = new Book { Name = "The Book #2", Authors = new List <Author> { new Author { FirstName = "Name #2", LastName = "Name ##2" } }, NumberOfPages = 1000, PublishYear = 1998, Publisher = "ACT", ISBNNumber = "85-359-0277-5" }; booksController.Create(to_add); Assert.IsTrue(GetBooks().Any(book => book.Name == to_add.Name)); }
public void Create_returns_ViewResult_with_new_Book() { var userId = "foxyboots9-guid"; var mockDbContext = new MockContext(); var controller = new BooksController(mockDbContext.Object, () => userId); var result = controller.Create() as ViewResult; Assert.IsNotNull(result); Assert.IsInstanceOf(typeof(Book), result.Model); }
public void ShouldReturnCreatePageOnGetCreate() { var booksController = new BooksController(); var createABookView = booksController.Create(); var model = (BookInformation)createABookView.Model; Assert.AreEqual("Add a Book", booksController.ViewBag.Title); Assert.IsInstanceOfType(model, typeof(BookInformation)); Assert.IsInstanceOfType(model.Model, typeof(Book)); }
public void TestM2() { BooksController book = new BooksController(); var result = book.Create(new Library.Models.Book { Id = 1234, Title = "Tytuł" }); Assert.IsNull(result); }
public async Task Create_should_return_Created_result() { // Arrange A.CallTo(() => _mediator.Send(A <AddBookCommand> .Ignored, A <CancellationToken> .Ignored)).Returns(new BookModel()); // Act var result = await _controller.Create(new NewBookModel()); // Assert Assert.IsType <CreatedAtActionResult>(result); A.CallTo(() => _mediator.Send(A <AddBookCommand> .Ignored, A <CancellationToken> .Ignored)).MustHaveHappenedOnceExactly(); }
public void Create_ValidModelState_ReturnsRedirectToIndex() { // Arrange _mockRepo.Setup(repo => repo.GetAll()).Returns(GetTestData()); _mockUnitOfWork.Setup(uow => uow.Books).Returns(_mockRepo.Object); var book = new BookViewModel() { Title = "New Book", Publisher = "ABC Publisher", Language = "English", ISBN = "123456789" }; // Act var result = _controller.Create(book); // Assert var viewResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", viewResult.ActionName); }
public void ShouldUseRepositoryWhenCreatingABook() { var book = new Book(); var bookInformation = new BookInformation(book); var mockedRepo = GetMockedRepo(); mockedRepo.Setup(repo => repo.Create(book)).Returns(new Book()); var booksController = new BooksController(mockedRepo.Object); booksController.Create(bookInformation); mockedRepo.Verify(repo => repo.Create(book)); }
public void CreateBookShouldNotSaveWhenBookIsInvalid() { var book = new Book(); var mockedRepo = new Mock<IRepository>(); var booksController = new BooksController(mockedRepo.Object); mockedRepo.Setup(repo => repo.Create(book)).Returns(book); booksController.ModelState.AddModelError("test error","test exception"); var result = (ViewResult)booksController.Create(book); 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["flash"]); }
public void CreateTest() { // arrange var mockRepo = new Mock <IBookService>(); var controller = new BooksController(mockRepo.Object); var newValidItem = new Book() { Author = "Author", Title = "Title", Description = "Description" }; // act var result = controller.Create(newValidItem); // assert var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result); Assert.Equal("Index", redirectToActionResult.ActionName); Assert.Null(redirectToActionResult.ControllerName); // arrange var newInvalidItem = new Book() { Title = "Title", Description = "Description" }; controller.ModelState.AddModelError("Author", "The Author value is required"); // act var resultInvalid = controller.Create(newInvalidItem); // assert var badRequestResult = Assert.IsType <BadRequestObjectResult>(resultInvalid); Assert.IsType <SerializableError>(badRequestResult.Value); }
public async Task Post_ReturnsBadRequest() { Book book = new Book(); Mock <IBooksRepository> mockRepo = new Mock <IBooksRepository>(); mockRepo.Setup(repo => repo.InsertAsync(book)).ReturnsAsync(() => null); BooksController controller = new BooksController(mockRepo.Object); IActionResult response = await controller.Create(book); Assert.IsType <BadRequestObjectResult>(response); ObjectResult objectResponse = response as ObjectResult; Assert.Equal(400, objectResponse.StatusCode); }
public void Create() { // Lets create a new book object Book newBook = new Book { Id = 3, BookName = "Book3", Authorname = "Author1" }; //Add the book object in the book object; controller.Create(newBook); List <Book> bookList = _booksRepo.GetAllBooks(); CollectionAssert.Contains(bookList, newBook); }
public void Books_Create_Get() { // Arrange var sources = GetTestSourceSet(); var db = new Mock <IPersonalInformationManagerContext>(); db.Setup(e => e.Sources).Returns(sources); BooksController controller = new BooksController(db.Object); // Act ViewResult result = controller.Create() as ViewResult; // Assert Assert.IsNotNull(result); }
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 async Task AddBook_ValidBook_ReturnsRedirectToActionResult() { var validBook = new Book() { name = "Higurashi", genre = "Horror", year = 2015 }; var service = new Mock <IBookRepository>(); var controller = new BooksController(service.Object); var result = await controller.Create(validBook); Assert.IsInstanceOfType(result, typeof(RedirectToActionResult)); }
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 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 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 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 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"]); }