11-implemented-second-part-of-tests-Order-CartItem-User-ShoppingCart

pom.xml

@@ -177,6 +177,11 @@
             <artifactId>jackson-databind</artifactId>
             <version>2.12.7.1</version>
         </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.23.1</version>
+        </dependency>
     </dependencies>
 
     <dependencyManagement>

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("[email protected]");
+        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("[email protected]");
+        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());
+    }
+}

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

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("[email protected]");
+        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<Order> actualOrders = orderRepository.findAllOrders(1L);
+        assertEquals(2, actualOrders.size());
+    }
+
+    @Test
+    @DisplayName("Find order with order items by ID")
+    void findOrderWithOrderItems() {
+        Optional<Order> 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<Order> 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<Order> 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<Order> 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());
+    }
+}

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<Role> foundRole = roleRepository.findRoleByName(Role.RoleName.USER);
+        assertThat(foundRole).isPresent();
+    }
+}

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 = "[email protected]";
+    @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<Role> userRoles = new HashSet<>();
+        userRoles.add(role);
+        user.setRoles(userRoles);
+    }
+
+    @Test
+    @DisplayName("find user using valid data")
+    void findUserByValidEmail_Success() {
+        userRepository.save(user);
+        Optional<User> foundUser = userRepository.findByEmail(VALID_EMAIL);
+        assertThat(foundUser).isNotEmpty();
+        assertThat(foundUser.get().getFirstName()).isEqualTo("Bob");
+    }
+
+    @Test
+    @DisplayName("find user using invalid data")
+    void findUserByNonExistentEmail() {
+        Optional<User> foundUser = userRepository.findByEmail("[email protected]");
+        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();
+    }
+}