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 TestM2()
{
BooksController book = new BooksController();
var result = book.Create(new Library.Models.Book {
Id = 1234,
Title = "Tytuł"
});
Assert.IsNull(result);
}
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"]);
}
