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));
+ }
+}