public void UpdateBook_ValidBook_Success()
{
// Arrange
var bookRequestDtos = new BookRequestDto
{
Id = 100,
Name = "Book 2",
CatId = 1,
ISBN = "1213244234",
PublishedDate = new DateTime(2019, 10, 1)
};
var bookResponseDtos = new BookResponseDto
{
Id = 100,
Name = "Book 2",
CatId = 1,
ISBN = "1213244234",
PublishedDate = new DateTime(2019, 11, 1)
};
_bookServiceMock.Setup(c => c.Update(bookRequestDtos.Id, bookRequestDtos)).Returns(bookResponseDtos);
_booksApiController = new BooksApiController(_bookServiceMock.Object);
// Act
var result = _booksApiController.Put(bookRequestDtos.Id, bookRequestDtos);
// Assert
var resultStatusCode = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode;
var resultValue = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
Assert.Equal((int)HttpStatusCode.Accepted, resultStatusCode);
Assert.Equal(bookResponseDtos, resultValue);
}
/// <summary>
/// Updates the specified book.
/// </summary>
/// <param name="id">The book identifier.</param>
/// <param name="requestDto">The request dto.</param>
/// <returns>Updated book</returns>
public async Task <BookResponseDto> Update(int id, BookRequestDto requestDto, string uploadedImageUrl)
{
BookResponseDto book = null;
SqlConnection connection = _dBContext.GetConnection();
SqlCommand command = new SqlCommand("sp_books_update", connection)
{
CommandType = System.Data.CommandType.StoredProcedure
};
command.Parameters.AddWithValue("@id", id);
command.Parameters.AddWithValue("@description", requestDto.Description);
command.Parameters.AddWithValue("@author", requestDto.Author);
command.Parameters.AddWithValue("@title", requestDto.Title);
command.Parameters.AddWithValue("@image", uploadedImageUrl);
command.Parameters.AddWithValue("@price", requestDto.Price);
command.Parameters.AddWithValue("@quantity", requestDto.Quantity);
await connection.OpenAsync();
using (SqlDataReader reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
book = MapReaderTobook(reader);
}
}
await connection.CloseAsync();
return(book);
}
public async Task CreateBook_ValidBook_Success()
{
// Arrange
var bookRequestDtos = new BookRequestDto
{
Id = 0,
Name = "Book 1",
CatId = 1,
ISBN = "1213244234"
};
var bookResponseDtos = new BookResponseDto
{
Id = 100,
Name = "Book 1",
CatId = 1,
ISBN = "1213244234"
};
_bookServiceMock.Setup(c => c.CreateAsync(bookRequestDtos)).ReturnsAsync(bookResponseDtos);
_booksApiController = new BooksApiController(_bookServiceMock.Object);
// Act
var result = await _booksApiController.Post(bookRequestDtos);
// Assert
var resultStatusCode = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode;
var resultValue = (BookResponseDto)((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
Assert.Equal((int)HttpStatusCode.Created, resultStatusCode);
Assert.Equal(bookResponseDtos, resultValue);
}
public async Task BorrowABook_BookExistFailedToBorrow_NoContent()
{
// Arrange
var bookId = 1;
var userId = "2";
var bookLendingRequest = new BookLendingRequestDto
{
BookId = bookId,
Id = 1,
UserId = userId
};
var bookInfo = new BookResponseDto
{
Id = bookId,
Name = "Book 1",
PublishedDate = new DateTime(2015, 10, 1),
Available2Lend = true
};
_bookServiceMock.Setup(c => c.GetByIdAsync(bookLendingRequest.BookId)).ReturnsAsync(bookInfo);
_bookLendingServiceMock.Setup(c => c.BookLending(bookLendingRequest)).ReturnsAsync((BookLendingResponseDto)null);
_bookLendingApiController = new BookLendingApiController(_bookLendingServiceMock.Object, _bookServiceMock.Object);
// Act
var result = await _bookLendingApiController.Post(bookLendingRequest);
// Assert
var resultStatus = ((Microsoft.AspNetCore.Mvc.NoContentResult)result).StatusCode;
Assert.Equal((int)HttpStatusCode.NoContent, resultStatus);
}
private bool BookResponseEquals(BookResponseDto leftBook, BookResponseDto rightBook) => Equals(leftBook.GetType()
.GetProperties()
.FirstOrDefault(prop =>
{
var leftValue = prop.GetValue(leftBook, null);
var rightValue = prop.GetValue(rightBook, null);
return(prop.Name == "Id" ? (Guid)leftValue != (Guid)rightValue : leftValue != rightValue);
}), null);
public async Task <IActionResult> AddBook([FromForm] BookRequestDto requestDto)
{
string email = (string)HttpContext.Items["email"];
BookResponseDto responseDto = await _service.AddBook(requestDto, email);
return(Ok(new Response <BookResponseDto> {
StatusCode = (int)HttpStatusCode.OK,
Message = ResponseMessage.BOOK_ADDED,
Data = responseDto
}));
}
public async Task PostAsync_ReturnCreatedBook()
{
var requestDto = new BookRequestDto();
var responseDto = new BookResponseDto();
_booksService.Setup(bs => bs.PostAsync(requestDto)).ReturnsAsync(responseDto);
var result = await _booksController.PostAsync(requestDto);
Assert.That(result.Value, Is.EqualTo(responseDto));
_booksService.Verify(bs => bs.PostAsync(requestDto));
}
public async Task GetAsync_ReturnBook()
{
var bookDto = new BookResponseDto();
var bookId = Guid.NewGuid();
_booksService.Setup(bs => bs.GetAsync(bookId)).ReturnsAsync(bookDto);
var result = await _booksController.GetAsync(bookId);
Assert.That(result.Value, Is.EqualTo(bookDto));
_booksService.Verify(bs => bs.GetAsync(It.IsAny <Guid>()));
}
/// <summary>
/// Performs business logic while adding book.
/// </summary>
/// <param name="requestDto">The request dto.</param>
/// <returns>BookResponseDto object</returns>
/// <exception cref="BookstoreException">Invalid data</exception>
public async Task <BookResponseDto> AddBook(BookRequestDto requestDto, string email)
{
try
{
string uploadedImageUrl = await _cloudService.UpdloadToCloud(requestDto.Image, email);
int id = await _repository.Insert(requestDto, uploadedImageUrl);
BookResponseDto response = _mapper.Map <BookResponseDto>(requestDto);
response.Id = id;
response.Image = uploadedImageUrl;
return(response);
}
catch (SqlException e) when(e.Number == SqlErrorNumbers.CONSTRAINT_VOILATION)
{
throw new BookstoreException("Invalid data");
}
}
public async Task <IActionResult> GetBook(int id)
{
BookResponseDto book = await _service.Get(id);
if (book == null)
{
return(NotFound(new Response <BookResponseDto>
{
StatusCode = (int)HttpStatusCode.NotFound,
Message = ResponseMessage.BOOK_NOT_FOUND,
Data = book
}));
}
return(Ok(new Response <BookResponseDto>
{
StatusCode = (int)HttpStatusCode.OK,
Message = ResponseMessage.SUCCESSFUL,
Data = book
}));
}
public async Task <IActionResult> UpdateBook(int id, [FromForm] BookRequestDto requestDto)
{
string email = (HttpContext.Items["email"]).ToString();
BookResponseDto book = await _service.Update(id, requestDto, email);
if (book == null)
{
return(NotFound(new Response <BookResponseDto>
{
StatusCode = (int)HttpStatusCode.NotFound,
Message = ResponseMessage.BOOK_NOT_FOUND,
Data = book
}));
}
return(Ok(new Response <BookResponseDto>
{
StatusCode = (int)HttpStatusCode.OK,
Message = ResponseMessage.BOOK_UPDATED,
Data = book
}));
}
public async Task GetBook_BySlug_Success()
{
var bookSlug = Guid.NewGuid().ToString();
var bookResponseDtos = new BookResponseDto
{
Id = 3,
Name = "Book 3",
ISBN = "243547645664"
};
_bookServiceMock.Setup(c => c.GetBySlugAsync(bookSlug)).ReturnsAsync(bookResponseDtos);
_booksApiController = new BooksApiController(_bookServiceMock.Object);
// Act
var result = await _booksApiController.Get(bookSlug);
// Assert
var resultValue = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
var resultStatus = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode;
Assert.Equal((int)HttpStatusCode.OK, resultStatus);
Assert.Equal(bookResponseDtos, resultValue);
}
public async Task GetBook_ById_Success()
{
var bookIdStr = "2";
var bookResponseDtos = new BookResponseDto
{
Id = int.Parse(bookIdStr),
Name = "Book 2",
ISBN = "243547645664"
};
_bookServiceMock.Setup(c => c.GetByIdAsync(bookResponseDtos.Id)).ReturnsAsync(bookResponseDtos);
_booksApiController = new BooksApiController(_bookServiceMock.Object);
// Act
var result = await _booksApiController.Get(bookIdStr);
// Assert
var resultValue = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
var resultStatus = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode;
Assert.Equal((int)HttpStatusCode.OK, resultStatus);
Assert.Equal(bookResponseDtos, resultValue);
}
/// <summary>
/// Gets the specified book from database.
/// </summary>
/// <param name="id">The identifier.</param>
/// <returns>Book with given id</returns>
public async Task <BookResponseDto> Get(int id)
{
BookResponseDto book = null;
SqlConnection connection = _dBContext.GetConnection();
SqlCommand command = new SqlCommand("sp_books_detailed_view", connection)
{
CommandType = System.Data.CommandType.StoredProcedure
};
command.Parameters.AddWithValue("@id", id);
await connection.OpenAsync();
using (SqlDataReader reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
book = MapReaderTobook(reader);
}
}
await connection.CloseAsync();
return(book);
}
public async void ExistingAuthorPublishABook()
{
// Arrange
var authorId = Guid.NewGuid();
var request = new PublishBookRequestDto
{
Title = "New Title",
Summary = "Summary",
Genre = "Action"
};
var expected = new BookResponseDto
{
Title = "New Title",
Summary = "Summary",
Genre = "Action",
Id = Guid.NewGuid()
};
_mockAuthorRepository
.Setup(repo => repo.GetFirstOrDefault(aut => aut.Id == authorId))
.ReturnsAsync(new Author());
_mockBookRepository
.Setup(repo => repo.Create(It.IsAny <Book>(), true))
.ReturnsAsync(new Book {
Title = expected.Title, Summary = expected.Summary, Genre = expected.Genre, Id = expected.Id
});
_mockAuthorBookRepository
.Setup(repo => repo.Create(It.IsAny <AuthorBook>(), true))
.ReturnsAsync(new AuthorBook());
var authorService = SetupService();
// Act
var actual = await authorService.PublishBook(authorId, request);
// Assert
Assert.True(BookResponseEquals(expected, actual));
}
