diff --git a/pom.xml b/pom.xml index f7bbaa1..8ab12bf 100644 --- a/pom.xml +++ b/pom.xml @@ -177,6 +177,11 @@ jackson-databind 2.12.7.1 + + org.assertj + assertj-core + 3.23.1 + diff --git a/src/test/java/spring/boot/bookstore/controller/AuthControllerIntegrationTest.java b/src/test/java/spring/boot/bookstore/controller/AuthControllerIntegrationTest.java new file mode 100644 index 0000000..46cf645 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/controller/AuthControllerIntegrationTest.java @@ -0,0 +1,76 @@ +package spring.boot.bookstore.controller; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static spring.boot.bookstore.controller.CategoryControllerTest.convertObjectToJsonString; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.http.MediaType; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import spring.boot.bookstore.dto.user.UserLoginRequestDto; +import spring.boot.bookstore.dto.user.UserLoginResponseDto; +import spring.boot.bookstore.dto.user.UserRegistrationRequestDto; +import spring.boot.bookstore.dto.user.UserResponseDto; +import spring.boot.bookstore.security.AuthenticationService; +import spring.boot.bookstore.service.user.UserService; + +@ContextConfiguration(classes = {AuthControllerIntegrationTest.class}) +@ExtendWith(SpringExtension.class) +@WebMvcTest(AuthControllerIntegrationTest.class) +class AuthControllerIntegrationTest { + @InjectMocks + private AuthController authController; + @Mock + private UserService userService; + @Mock + private AuthenticationService authenticationService; + + @Test + @DisplayName("User registration") + void registerUser() throws Exception { + UserRegistrationRequestDto registrationRequest = new UserRegistrationRequestDto(); + registrationRequest.setEmail("test@example.com"); + registrationRequest.setFirstName("Bob"); + registrationRequest.setLastName("Doe"); + registrationRequest.setPassword("bobDob???orAlicon#$%^&*DFGHJ$%^&*45678"); + registrationRequest.setRepeatPassword("bobDob???orAlicon#$%^&*DFGHJ$%^&*45678"); + registrationRequest.setShippingAddress("123 main street"); + when(userService.register(any(UserRegistrationRequestDto.class))) + .thenReturn(new UserResponseDto()); + MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.post("/auth/register") + .contentType(MediaType.APPLICATION_JSON) + .content(convertObjectToJsonString(registrationRequest)); + MockMvcBuilders.standaloneSetup(authController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()); + } + + @Test + @DisplayName("User login with valid data") + void loginUser() throws Exception { + UserLoginRequestDto loginRequest = new UserLoginRequestDto(); + loginRequest.setEmail("test@example.com"); + loginRequest.setPassword("bobDob???orAlicon#$%^&*DFGHJ$%^&*45678"); + String token = "random_token_?"; + when(authenticationService.authenticate(any(UserLoginRequestDto.class))) + .thenReturn(new UserLoginResponseDto(token)); + MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.post("/auth/login") + .contentType(MediaType.APPLICATION_JSON) + .content(convertObjectToJsonString(loginRequest)); + MockMvcBuilders.standaloneSetup(authController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()); + } +} diff --git a/src/test/java/spring/boot/bookstore/controller/ShoppingCartControllerTest.java b/src/test/java/spring/boot/bookstore/controller/ShoppingCartControllerTest.java new file mode 100644 index 0000000..eabe618 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/controller/ShoppingCartControllerTest.java @@ -0,0 +1,98 @@ +package spring.boot.bookstore.controller; + +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; +import static spring.boot.bookstore.controller.CategoryControllerTest.convertObjectToJsonString; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest; +import org.springframework.http.MediaType; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.result.MockMvcResultMatchers; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import spring.boot.bookstore.dto.cartitem.CartItemRequestDto; +import spring.boot.bookstore.dto.cartitem.CartItemResponseDto; +import spring.boot.bookstore.dto.cartitem.UpdateQuantityDto; +import spring.boot.bookstore.dto.shoppingcart.ShoppingCartResponseDto; +import spring.boot.bookstore.service.cartitem.CartItemService; +import spring.boot.bookstore.service.shoppingcart.ShoppingCartService; + +@ContextConfiguration(classes = {ShoppingCartControllerTest.class}) +@ExtendWith(SpringExtension.class) +@WebMvcTest(ShoppingCartControllerTest.class) +class ShoppingCartControllerTest { + @InjectMocks + private ShoppingCartController shoppingCartController; + @Mock + private ShoppingCartService shoppingCartService; + @Mock + private CartItemService cartItemService; + + @Test + @DisplayName("adding item to the shoppingCart") + void addCartItemTest() throws Exception { + CartItemRequestDto cartItemRequestDto = new CartItemRequestDto(); + cartItemRequestDto.setBookId(3L); + cartItemRequestDto.setQuantity(14); + when(shoppingCartService.save(cartItemRequestDto)).thenReturn(new CartItemResponseDto()); + MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.post("/cart") + .contentType(MediaType.APPLICATION_JSON) + .content(convertObjectToJsonString(cartItemRequestDto)); + MockMvcBuilders.standaloneSetup(shoppingCartController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()); + } + + @Test + @DisplayName("get shopping cart") + void getShoppingCartTest() throws Exception { + ShoppingCartResponseDto shoppingCartResponseDto = new ShoppingCartResponseDto(); + when(shoppingCartService.getShoppingCart()).thenReturn(shoppingCartResponseDto); + MockHttpServletRequestBuilder requestBuilder = MockMvcRequestBuilders.get("/cart"); + MockMvcBuilders.standaloneSetup(shoppingCartController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()) + .andExpect(MockMvcResultMatchers.content() + .json(convertObjectToJsonString(shoppingCartResponseDto))); + } + + @Test + @DisplayName("update quantity in the Shopping Cart") + void updateCartItemTest() throws Exception { + UpdateQuantityDto updateQuantityDto = new UpdateQuantityDto(); + updateQuantityDto.setQuantity(3); + when(cartItemService.update(updateQuantityDto, 1L)).thenReturn(new CartItemResponseDto()); + MockHttpServletRequestBuilder requestBuilder = + MockMvcRequestBuilders.put("/cart/cart-items/1") + .contentType(MediaType.APPLICATION_JSON) + .content(convertObjectToJsonString(updateQuantityDto)); + MockMvcBuilders.standaloneSetup(shoppingCartController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()); + } + + @Test + @DisplayName("delete cart item by ID") + void deleteCartItemById() throws Exception { + Long cartItemId = 1L; + doNothing().when(this.cartItemService).delete(cartItemId); + MockHttpServletRequestBuilder requestBuilder = + MockMvcRequestBuilders.delete("/cart/" + cartItemId); + MockMvcBuilders.standaloneSetup(this.shoppingCartController) + .build() + .perform(requestBuilder) + .andExpect(status().isOk()); + + } +} diff --git a/src/test/java/spring/boot/bookstore/repository/OrderRepositoryIntegrationTest.java b/src/test/java/spring/boot/bookstore/repository/OrderRepositoryIntegrationTest.java new file mode 100644 index 0000000..b0cc8c1 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/repository/OrderRepositoryIntegrationTest.java @@ -0,0 +1,98 @@ +package spring.boot.bookstore.repository; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import spring.boot.bookstore.model.Order; +import spring.boot.bookstore.model.User; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +class OrderRepositoryIntegrationTest { + @Autowired + private OrderRepository orderRepository; + @Autowired + private UserRepository userRepository; + private User user; + private Order order; + + @BeforeEach + void setUp() { + user = new User(); + user.setId(1L); + user.setEmail("user@example.com"); + user.setPassword("password"); + user.setFirstName("John"); + user.setLastName("Doe"); + user.setShippingAddress("123 Main St"); + user = userRepository.save(user); + order = new Order(); + order.setUser(user); + order.setStatus(Order.Status.COMPLETED); + order.setTotal(BigDecimal.valueOf(100.0)); + order.setOrderDate(LocalDateTime.now()); + order.setShippingAddress("123 Main St"); + orderRepository.save(order); + } + + @Test + @DisplayName("Find all orders for a user with id ") + void findAllOrders() { + List actualOrders = orderRepository.findAllOrders(1L); + assertEquals(2, actualOrders.size()); + } + + @Test + @DisplayName("Find order with order items by ID") + void findOrderWithOrderItems() { + Optional actualOrder = orderRepository.findById(1L); + assertTrue(actualOrder.isPresent()); + } + + @Test + @DisplayName("Save Order and Verify Its ID") + void saveOrder() { + Order savedOrder = orderRepository.save(order); + assertNotNull(savedOrder.getId()); + Optional retrievedOrder = orderRepository.findById(savedOrder.getId()); + assertTrue(retrievedOrder.isPresent()); + } + + @Test + @DisplayName("Delete Order and Ensure It's Removed") + void deleteOrder() { + Order savedOrder = orderRepository.save(order); + orderRepository.delete(savedOrder); + Optional retrievedOrder = orderRepository.findById(savedOrder.getId()); + assertTrue(retrievedOrder.isEmpty()); + } + + @Test + @DisplayName("Find Orders by User") + void findOrdersByUser() { + User user = userRepository.findById(1L).orElse(null); + assertNotNull(user); + List orders = orderRepository.findAllOrders(user.getId()); + assertEquals(2, orders.size()); + } + + @Test + @DisplayName("Update Order Status") + void updateOrder() { + Order savedOrder = orderRepository.save(order); + savedOrder.setStatus(Order.Status.PENDING); + Order updatedOrder = orderRepository.save(savedOrder); + assertEquals(Order.Status.PENDING, updatedOrder.getStatus()); + } +} diff --git a/src/test/java/spring/boot/bookstore/repository/RoleRepositoryTest.java b/src/test/java/spring/boot/bookstore/repository/RoleRepositoryTest.java new file mode 100644 index 0000000..2cc15b9 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/repository/RoleRepositoryTest.java @@ -0,0 +1,25 @@ +package spring.boot.bookstore.repository; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.Optional; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import spring.boot.bookstore.model.Role; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +class RoleRepositoryTest { + @Autowired + private RoleRepository roleRepository; + + @Test + @DisplayName("find role by name") + public void findRoleByName() { + Optional foundRole = roleRepository.findRoleByName(Role.RoleName.USER); + assertThat(foundRole).isPresent(); + } +} diff --git a/src/test/java/spring/boot/bookstore/repository/UserRepositoryTest.java b/src/test/java/spring/boot/bookstore/repository/UserRepositoryTest.java new file mode 100644 index 0000000..51acbd9 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/repository/UserRepositoryTest.java @@ -0,0 +1,80 @@ +package spring.boot.bookstore.repository; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.HashSet; +import java.util.Optional; +import java.util.Set; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import spring.boot.bookstore.model.Role; +import spring.boot.bookstore.model.User; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +class UserRepositoryTest { + private static final String VALID_EMAIL = "test@example.com"; + @Autowired + private UserRepository userRepository; + private User user; + private Role role; + + @BeforeEach + void setUp() { + role = new Role(); + role.setId(1L); + role.setName(Role.RoleName.USER); + user = new User(); + user.setEmail(VALID_EMAIL); + user.setPassword("password567$%^&"); + user.setFirstName("Bob"); + user.setLastName("User"); + Set userRoles = new HashSet<>(); + userRoles.add(role); + user.setRoles(userRoles); + } + + @Test + @DisplayName("find user using valid data") + void findUserByValidEmail_Success() { + userRepository.save(user); + Optional foundUser = userRepository.findByEmail(VALID_EMAIL); + assertThat(foundUser).isNotEmpty(); + assertThat(foundUser.get().getFirstName()).isEqualTo("Bob"); + } + + @Test + @DisplayName("find user using invalid data") + void findUserByNonExistentEmail() { + Optional foundUser = userRepository.findByEmail("nonexistent@example.com"); + assertThat(foundUser).isEmpty(); + } + + @Test + @DisplayName("Update user details") + void updateUser() { + userRepository.save(user); + User updatedUser = userRepository.findByEmail(VALID_EMAIL).orElse(null); + assertThat(updatedUser).isNotNull(); + updatedUser.setFirstName("UpdatedFirstName"); + userRepository.save(updatedUser); + User retrievedUser = userRepository.findByEmail(VALID_EMAIL).orElse(null); + assertThat(retrievedUser).isNotNull(); + assertThat(retrievedUser.getFirstName()).isEqualTo("UpdatedFirstName"); + } + + @Test + @DisplayName("delete user from db") + void deleteUser() { + userRepository.save(user); + User retrievedUser = userRepository.findByEmail(VALID_EMAIL).orElse(null); + assertThat(retrievedUser).isNotNull(); + userRepository.delete(retrievedUser); + User deletedUser = userRepository.findByEmail(VALID_EMAIL).orElse(null); + assertThat(deletedUser).isNull(); + } +} diff --git a/src/test/java/spring/boot/bookstore/repository/cartitem/CartItemRepositoryTest.java b/src/test/java/spring/boot/bookstore/repository/cartitem/CartItemRepositoryTest.java new file mode 100644 index 0000000..439dc64 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/repository/cartitem/CartItemRepositoryTest.java @@ -0,0 +1,75 @@ +package spring.boot.bookstore.repository.cartitem; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.math.BigDecimal; +import java.util.Set; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import spring.boot.bookstore.model.Book; +import spring.boot.bookstore.model.CartItem; +import spring.boot.bookstore.model.ShoppingCart; +import spring.boot.bookstore.model.User; +import spring.boot.bookstore.repository.BookRepository; +import spring.boot.bookstore.repository.UserRepository; +import spring.boot.bookstore.repository.shoppingcart.ShoppingCartRepository; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.AUTO_CONFIGURED) +class CartItemRepositoryTest { + @Autowired + private CartItemRepository cartItemRepository; + @Autowired + private ShoppingCartRepository shoppingCartRepository; + @Autowired + private UserRepository userRepository; + @Autowired + private BookRepository bookRepository; + private User user; + + @BeforeEach + void setUp() { + user = new User(); + user.setFirstName("Bob"); + user.setLastName("Alison"); + user.setEmail("example@example.com"); + user.setPassword("password"); + userRepository.save(user); + } + + @Test + @DisplayName("find Cart Item By ShoppingCart Id") + void findCartItemByShoppingCartId() { + ShoppingCart savedShoppingCart = new ShoppingCart(); + savedShoppingCart.setUser(user); + savedShoppingCart = shoppingCartRepository.save(savedShoppingCart); + Book book = new Book(); + book.setTitle("Sample Book"); + book.setAuthor("Sample Author"); + book.setIsbn("5678"); + book.setPrice(BigDecimal.valueOf(29.99)); + book = bookRepository.save(book); + CartItem cartItem1 = new CartItem(); + cartItem1.setShoppingCart(savedShoppingCart); + cartItem1.setBook(book); + cartItemRepository.save(cartItem1); + Set result = cartItemRepository + .findCartItemByShoppingCartId(savedShoppingCart.getId()); + assertEquals(1, result.size()); + } + + @Test + @DisplayName("find Cart Items By Shopping CartId Expect No Result") + void findCartItemsByShoppingCartId_ExpectNoResult() { + ShoppingCart savedShoppingCart = new ShoppingCart(); + savedShoppingCart.setUser(user); + Long nonExistentShoppingCartId = 999L; + Set result = cartItemRepository + .findCartItemByShoppingCartId(nonExistentShoppingCartId); + assertEquals(0, result.size()); + } +} diff --git a/src/test/java/spring/boot/bookstore/repository/shoppingcart/ShoppingCartRepositoryIntegrationTest.java b/src/test/java/spring/boot/bookstore/repository/shoppingcart/ShoppingCartRepositoryIntegrationTest.java new file mode 100644 index 0000000..fc67917 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/repository/shoppingcart/ShoppingCartRepositoryIntegrationTest.java @@ -0,0 +1,77 @@ +package spring.boot.bookstore.repository.shoppingcart; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.boot.test.mock.mockito.MockBean; +import spring.boot.bookstore.model.CartItem; +import spring.boot.bookstore.model.ShoppingCart; + +@DataJpaTest +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.AUTO_CONFIGURED) +class ShoppingCartRepositoryIntegrationTest { + private static final Long VALID_ID = 1L; + @MockBean + private ShoppingCartRepository shoppingCartRepository; + @Mock + private CartItem cartItem; + + @Test + @DisplayName("get user by id") + void getUserById() { + ShoppingCart shoppingCart = new ShoppingCart(); + shoppingCart.setId(VALID_ID); + when(shoppingCartRepository.getUserById(any())).thenReturn(Optional.of(shoppingCart)); + Optional result = shoppingCartRepository.getUserById(VALID_ID); + assertEquals(shoppingCart, result.get()); + } + + @Test + @DisplayName("get User By Id Not Found") + void getUserById_NotFound() { + when(shoppingCartRepository.getUserById(any())).thenReturn(Optional.empty()); + Optional result = shoppingCartRepository.getUserById(VALID_ID); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("find by id ") + void findById() { + ShoppingCart shoppingCart = new ShoppingCart(); + List cartItems = new ArrayList<>(); + cartItems.add(cartItem); + shoppingCart.setCartItems(cartItems); + when(shoppingCartRepository.findById(VALID_ID)).thenReturn(Optional.of(shoppingCart)); + Optional result = shoppingCartRepository.findById(VALID_ID); + assertEquals(shoppingCart, result.orElse(null)); + } + + @Test + @DisplayName("find Non Existing ShoppingCart Expect Failure") + void findNonExistingShoppingCart_ExpectFailure() { + when(shoppingCartRepository.getUserById(any())).thenReturn(Optional.empty()); + Optional result = shoppingCartRepository.getUserById(VALID_ID); + assertTrue(result.isEmpty()); + } + + @Test + @DisplayName("delete ShoppingCart") + void deleteShoppingCart() { + ShoppingCart shoppingCart = new ShoppingCart(); + shoppingCartRepository.save(shoppingCart); + Long savedId = shoppingCart.getId(); + shoppingCartRepository.delete(shoppingCart); + Optional deleteCart = shoppingCartRepository.getUserById(savedId); + assertTrue(deleteCart.isEmpty()); + } +} diff --git a/src/test/java/spring/boot/bookstore/service/cartitem/impl/CartItemServiceImplTest.java b/src/test/java/spring/boot/bookstore/service/cartitem/impl/CartItemServiceImplTest.java new file mode 100644 index 0000000..7a2f368 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/service/cartitem/impl/CartItemServiceImplTest.java @@ -0,0 +1,178 @@ +package spring.boot.bookstore.service.cartitem.impl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.Optional; +import java.util.Set; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.test.context.junit4.SpringRunner; +import spring.boot.bookstore.dto.cartitem.CartItemRequestDto; +import spring.boot.bookstore.dto.cartitem.CartItemResponseDto; +import spring.boot.bookstore.dto.cartitem.UpdateQuantityDto; +import spring.boot.bookstore.exception.EntityNotFoundException; +import spring.boot.bookstore.mapper.CartItemMapper; +import spring.boot.bookstore.model.Book; +import spring.boot.bookstore.model.CartItem; +import spring.boot.bookstore.model.ShoppingCart; +import spring.boot.bookstore.model.User; +import spring.boot.bookstore.repository.BookRepository; +import spring.boot.bookstore.repository.cartitem.CartItemRepository; +import spring.boot.bookstore.repository.shoppingcart.ShoppingCartRepository; +import spring.boot.bookstore.service.user.UserService; + +@ExtendWith(MockitoExtension.class) +@RunWith(SpringRunner.class) +class CartItemServiceImplTest { + private static final Long INVALID_ID = -1L; + private static final Long VALID_SHOPPING_CART_ID = 1L; + private static final Book VALID_BOOK = new Book(); + private static final User VALID_USER = new User(); + private static final ShoppingCart VALID_SHOPPING_CART = new ShoppingCart(); + private static final CartItemRequestDto VALID_REQUEST = new CartItemRequestDto(); + private static final CartItemResponseDto VALID_RESPONSE_DTO = new CartItemResponseDto(); + private static final CartItem VALID_CART_ITEM = new CartItem(); + private static final UpdateQuantityDto VALID_UPDATE_REQUEST = new UpdateQuantityDto(); + + @InjectMocks + private CartItemServiceImpl cartItemService; + @Mock + private UserService userService; + @Mock + private CartItemRepository cartItemRepository; + @Mock + private CartItemMapper cartItemMapper; + @Mock + private BookRepository bookRepository; + @Mock + private ShoppingCartRepository shoppingCartRepository; + + @BeforeEach + void setUp() { + VALID_BOOK.setId(1L); + VALID_BOOK.setTitle("Viy"); + VALID_BOOK.setAuthor("Nikolai Gogol"); + VALID_BOOK.setIsbn("66-666-66"); + VALID_BOOK.setPrice(new BigDecimal("689.00")); + VALID_BOOK.setDescription("is a horror novella by the writer Nikolai Gogol," + + " first published in volume 2 of his collection of " + + "tales entitled Mirgorod (1835)."); + + VALID_USER.setId(1L); + VALID_USER.setFirstName("Bob"); + VALID_USER.setLastName("Alison"); + VALID_USER.setEmail("bobEmail@i.ua"); + VALID_USER.setPassword("password"); + + VALID_SHOPPING_CART.setId(1L); + VALID_SHOPPING_CART.setUser(VALID_USER); + VALID_SHOPPING_CART.setCartItems(new ArrayList<>()); + + VALID_REQUEST.setBookId(VALID_BOOK.getId()); + VALID_REQUEST.setQuantity(2); + + VALID_CART_ITEM.setId(1L); + VALID_CART_ITEM.setBook(VALID_BOOK); + VALID_CART_ITEM.setQuantity(VALID_REQUEST.getQuantity()); + VALID_CART_ITEM.setShoppingCart(VALID_SHOPPING_CART); + + VALID_RESPONSE_DTO.setId(VALID_CART_ITEM.getId()); + VALID_RESPONSE_DTO.setBookId(VALID_CART_ITEM.getId()); + VALID_RESPONSE_DTO.setBookTitle(VALID_CART_ITEM.getBook().getTitle()); + VALID_RESPONSE_DTO.setQuantity(VALID_CART_ITEM.getQuantity()); + + VALID_UPDATE_REQUEST.setQuantity(100); + } + + @Test + @DisplayName("save cartItem and return correct cart item response") + void saveCartItem_thenReturnCartItemResponseDto() { + when(userService.getAuthenticated()).thenReturn(VALID_USER); + when(bookRepository.getById(VALID_REQUEST.getBookId())).thenReturn(VALID_BOOK); + when(shoppingCartRepository.getUserById(VALID_USER.getId())) + .thenReturn(Optional.of(VALID_SHOPPING_CART)); + when(cartItemMapper.toDto(cartItemRepository.save(VALID_CART_ITEM))) + .thenReturn(VALID_RESPONSE_DTO); + + CartItemResponseDto cartItemResponseDto = cartItemService.save(VALID_REQUEST); + + assertEquals(VALID_RESPONSE_DTO, cartItemResponseDto); + } + + @Test + @DisplayName("update cart item quantity and then return correct cart item response ") + void updateCartItemQuantity_thenReturnCartItemResponseDto() { + when(cartItemRepository.findById(VALID_CART_ITEM.getId())) + .thenReturn(Optional.of(VALID_CART_ITEM)); + when(cartItemMapper.toDto(cartItemRepository.save(VALID_CART_ITEM))) + .thenReturn(VALID_RESPONSE_DTO); + CartItemResponseDto cartItemResponseDto = cartItemService + .update(VALID_UPDATE_REQUEST, VALID_CART_ITEM.getId()); + assertEquals(VALID_RESPONSE_DTO, cartItemResponseDto); + } + + @Test + @DisplayName("find by shopping cart id using valid id and return item ") + void findByShoppingCartId_validId_returnOneItem() { + when(cartItemRepository.findCartItemByShoppingCartId(anyLong())) + .thenReturn(Set.of(VALID_CART_ITEM)); + when(cartItemMapper.toDto(any())).thenReturn(VALID_RESPONSE_DTO); + + Set actual = cartItemService + .findByShoppingCartId(VALID_SHOPPING_CART_ID); + assertNotNull(actual); + assertEquals(1, actual.size()); + assertEquals(Set.of(VALID_RESPONSE_DTO), actual); + verify(cartItemRepository, times(1)) + .findCartItemByShoppingCartId(anyLong()); + verify(cartItemMapper, times(1)).toDto(any()); + verifyNoMoreInteractions(cartItemMapper, cartItemRepository); + } + + @Test + @DisplayName("Verify update() method") + void update_validUpdateRequest_returnResponse() { + when(cartItemRepository.findById(anyLong())) + .thenReturn(Optional.of(VALID_CART_ITEM)); + when(cartItemRepository.save(any())).thenReturn(VALID_CART_ITEM); + when(cartItemMapper.toDto(any())).thenReturn(VALID_RESPONSE_DTO); + CartItemResponseDto actual = cartItemService.update(VALID_UPDATE_REQUEST, 1L); + VALID_RESPONSE_DTO.setQuantity(VALID_UPDATE_REQUEST.getQuantity()); + assertNotNull(actual); + assertEquals(VALID_RESPONSE_DTO, actual); + verify(cartItemRepository, times(1)).findById(anyLong()); + verify(cartItemRepository, times(1)).save(any()); + verify(cartItemMapper, times(1)).toDto(any()); + verifyNoMoreInteractions(cartItemMapper, cartItemRepository); + } + + @Test + @DisplayName("Verify update() method with non-existent cart item") + void update_nonExistentCartItem_throwException() { + assertThrows(EntityNotFoundException.class, + () -> cartItemService.update(VALID_UPDATE_REQUEST, INVALID_ID)); + } + + @Test + @DisplayName("Verify delete() method with non-existent cart item") + void delete_nonExistentCartItem_throwException() { + assertThrows(EntityNotFoundException.class, + () -> cartItemService.delete(INVALID_ID)); + } +} diff --git a/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartManagerTest.java b/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartManagerTest.java new file mode 100644 index 0000000..15bb2ac --- /dev/null +++ b/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartManagerTest.java @@ -0,0 +1,53 @@ +package spring.boot.bookstore.service.shoppingcart.impl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.verify; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.test.context.junit4.SpringRunner; +import spring.boot.bookstore.model.ShoppingCart; +import spring.boot.bookstore.model.User; +import spring.boot.bookstore.repository.shoppingcart.ShoppingCartRepository; + +@ExtendWith(MockitoExtension.class) +@RunWith(SpringRunner.class) +class ShoppingCartManagerTest { + @InjectMocks + private ShoppingCartManager shoppingCartManager; + @Mock + private ShoppingCartRepository shoppingCartRepository; + private User user; + + @BeforeEach + void setUp() { + user = new User(); + user.setId(1L); + user.setFirstName("Bob"); + user.setLastName("Bobovchenko"); + user.setEmail("newBobMail@gmail.com"); + user.setPassword("BobDon`tLikeMakeNewPAssword_%^&*4567"); + } + + @Test + void testRegisterNewCartWithValidUser() { + ShoppingCart newCart = shoppingCartManager.registerNewCart(user); + Long cartId = newCart.getId(); + assertEquals(newCart.getUser(), user); + assertEquals(newCart.getId(), cartId); + } + + @Test + void testRegisterNewCartWithRepositorySave() { + ShoppingCart newCart = shoppingCartManager.registerNewCart(user); + Long cartId = newCart.getId(); + assertEquals(newCart.getUser(), user); + assertEquals(newCart.getId(), cartId); + verify(shoppingCartRepository).save(newCart); + } +} diff --git a/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartServiceImplTest.java b/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartServiceImplTest.java new file mode 100644 index 0000000..f2e184c --- /dev/null +++ b/src/test/java/spring/boot/bookstore/service/shoppingcart/impl/ShoppingCartServiceImplTest.java @@ -0,0 +1,83 @@ +package spring.boot.bookstore.service.shoppingcart.impl; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.when; + +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.test.context.junit4.SpringRunner; +import spring.boot.bookstore.dto.cartitem.CartItemRequestDto; +import spring.boot.bookstore.dto.cartitem.CartItemResponseDto; +import spring.boot.bookstore.dto.shoppingcart.ShoppingCartResponseDto; +import spring.boot.bookstore.model.ShoppingCart; +import spring.boot.bookstore.model.User; +import spring.boot.bookstore.repository.shoppingcart.ShoppingCartRepository; +import spring.boot.bookstore.service.cartitem.CartItemService; +import spring.boot.bookstore.service.user.UserService; + +@ExtendWith(MockitoExtension.class) +@RunWith(SpringRunner.class) +class ShoppingCartServiceImplTest { + @InjectMocks + private ShoppingCartServiceImpl shoppingCartService; + @Mock + private CartItemService cartItemService; + @Mock + private UserService userService; + @Mock + private ShoppingCartRepository shoppingCartRepository; + private User user; + + @BeforeEach + void setUp() { + user = new User(); + user.setFirstName("Bob"); + user.setLastName("Alison"); + user.setEmail("bob@gmail.com"); + user.setPassword("newBobPassword78%&*(_"); + } + + @Test + @DisplayName("save shopping cart") + void save() { + CartItemRequestDto requestDto = new CartItemRequestDto(); + requestDto.setBookId(1L); + requestDto.setQuantity(4); + when(cartItemService.save(requestDto)).thenReturn(new CartItemResponseDto()); + CartItemResponseDto response = shoppingCartService.save(requestDto); + assertNotNull(response); + } + + @Test + @DisplayName("get Shopping Cart When User Authenticated") + void getShoppingCartWhenUserAuthenticated() { + when(userService.getAuthenticated()).thenReturn(user); + ShoppingCart shoppingCart = new ShoppingCart(); + shoppingCart.setId(2L); + when(shoppingCartRepository.getUserById(user.getId())) + .thenReturn(Optional.of(shoppingCart)); + ShoppingCartResponseDto response = shoppingCartService.getShoppingCart(); + assertNotNull(response); + assertEquals(2L, response.getId()); + } + + @Test + @DisplayName("get Shopping Cart") + void getShoppingCart() { + ShoppingCart shoppingCart = new ShoppingCart(); + shoppingCart.setUser(user); + when(userService.getAuthenticated()).thenReturn(user); + when(shoppingCartRepository.getUserById(user.getId())) + .thenReturn(Optional.of(shoppingCart)); + ShoppingCartResponseDto response = shoppingCartService.getShoppingCart(); + assertNotNull(response); + } +} diff --git a/src/test/java/spring/boot/bookstore/service/user/impl/UserServiceImplTest.java b/src/test/java/spring/boot/bookstore/service/user/impl/UserServiceImplTest.java new file mode 100644 index 0000000..531a4d2 --- /dev/null +++ b/src/test/java/spring/boot/bookstore/service/user/impl/UserServiceImplTest.java @@ -0,0 +1,91 @@ +package spring.boot.bookstore.service.user.impl; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +import java.util.Optional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContext; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.test.context.junit4.SpringRunner; +import spring.boot.bookstore.dto.user.UserRegistrationRequestDto; +import spring.boot.bookstore.exception.RegistrationException; +import spring.boot.bookstore.model.User; +import spring.boot.bookstore.repository.UserRepository; + +@ExtendWith(MockitoExtension.class) +@RunWith(SpringRunner.class) +class UserServiceImplTest { + @InjectMocks + private UserServiceImpl userService; + @Mock + private UserRepository userRepository; + private UserRegistrationRequestDto registrationRequest = new UserRegistrationRequestDto(); + + @BeforeEach + void setUp() { + registrationRequest = new UserRegistrationRequestDto(); + registrationRequest.setFirstName("John"); + registrationRequest.setLastName("Alison"); + registrationRequest.setEmail("test@example.com"); + registrationRequest.setPassword("password%^&*("); + registrationRequest.setRepeatPassword("password%^&*("); + registrationRequest.setShippingAddress("123 Main St"); + SecurityContext securityContext = SecurityContextHolder.createEmptyContext(); + Authentication authentication = + new UsernamePasswordAuthenticationToken("test@example.com", "password"); + securityContext.setAuthentication(authentication); + SecurityContextHolder.setContext(securityContext); + } + + @Test + @DisplayName("Successful Registration") + void successfulRegistration() { + when(userRepository.findByEmail(anyString())).thenReturn(Optional.of(new User())); + assertThrows(RegistrationException.class, () -> { + userService.register(registrationRequest); + }); + } + + @Test + @DisplayName("Registration With Existing Email") + void registrationWithExistingEmail() { + when(userRepository.findByEmail(anyString())).thenReturn(Optional.of(new User())); + assertThrows(RegistrationException.class, () -> userService.register(registrationRequest)); + } + + @Test + @DisplayName("Get Authenticated User") + void getAuthenticatedUser() { + User authenticatedUser = new User(); + when(userRepository.findByEmail("test@example.com")) + .thenReturn(Optional.of(authenticatedUser)); + User retrievedUser = userService.getAuthenticated(); + assertThat(retrievedUser).isEqualTo(authenticatedUser); + } + + @Test + @DisplayName("Registration With Existing Email Throws Exception") + void registrationWithExistingEmail_ThrowsException() { + when(userRepository.findByEmail(anyString())).thenReturn(Optional.of(new User())); + assertThrows(RegistrationException.class, () -> userService.register(registrationRequest)); + } + + @Test + @DisplayName("Registration With Non-Unique Email") + void testRegistrationWithNonUniqueEmail() { + when(userRepository.findByEmail(anyString())).thenReturn(Optional.of(new User())); + assertThrows(RegistrationException.class, () -> userService.register(registrationRequest)); + } +}