Order Tests added

src/test/java/_11/asktpk/artisanconnectbackend/OrderControllerTest.java

@@ -0,0 +1,235 @@
+package _11.asktpk.artisanconnectbackend;
+
+import _11.asktpk.artisanconnectbackend.controller.OrderController;
+import _11.asktpk.artisanconnectbackend.dto.*;
+import _11.asktpk.artisanconnectbackend.entities.Client;
+import _11.asktpk.artisanconnectbackend.entities.Notice;
+import _11.asktpk.artisanconnectbackend.entities.Order;
+import _11.asktpk.artisanconnectbackend.entities.Payment;
+import _11.asktpk.artisanconnectbackend.service.OrderService;
+import _11.asktpk.artisanconnectbackend.service.PaymentService;
+import _11.asktpk.artisanconnectbackend.utils.Enums;
+import _11.asktpk.artisanconnectbackend.utils.Tools;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import jakarta.servlet.http.HttpServletRequest;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class OrderControllerTest {
+
+    private final OrderService orderService = Mockito.mock(OrderService.class);
+    private final PaymentService paymentService = Mockito.mock(PaymentService.class);
+    private final Tools tools = Mockito.mock(Tools.class);
+    private final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
+
+    private OrderController orderController;
+
+    @BeforeEach
+    public void setUp() {
+        orderController = new OrderController(orderService, paymentService, tools);
+    }
+
+    @Test
+    @DisplayName("Test dodawania zamówienia")
+    public void testAddOrder() {
+        OrderDTO orderDTO = new OrderDTO();
+        orderDTO.setClientId(1L);
+        orderDTO.setNoticeId(1L);
+        orderDTO.setOrderType(Enums.OrderType.ACTIVATION);
+
+        when(tools.getClientIdFromRequest(request)).thenReturn(1L);
+        when(orderService.addOrder(orderDTO)).thenReturn(1L);
+
+        ResponseEntity<?> response = orderController.addClient(orderDTO, request);
+
+        assertEquals(HttpStatus.CREATED, response.getStatusCode(), "Status odpowiedzi powinien być 201 CREATED");
+        assertEquals(1L, response.getBody(), "Ciało odpowiedzi powinno zawierać ID zamówienia");
+
+        System.out.println("Test dodawania zamówienia przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test zmiany statusu zamówienia")
+    public void testChangeStatus() {
+        OrderStatusDTO orderStatusDTO = new OrderStatusDTO();
+        orderStatusDTO.setId(1L);
+        orderStatusDTO.setStatus(Enums.OrderStatus.COMPLETED);
+
+        when(orderService.changeOrderStatus(1L, Enums.OrderStatus.COMPLETED)).thenReturn(1L);
+
+        ResponseEntity<?> response = orderController.changeStatus(orderStatusDTO);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
+        assertEquals(1L, response.getBody(), "Ciało odpowiedzi powinno zawierać ID zamówienia");
+
+        System.out.println("Test zmiany statusu zamówienia przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania tokena płatności")
+    public void testFetchToken() {
+        Long orderId = 1L;
+        Order order = new Order();
+        order.setId(orderId);
+        order.setAmount(10.00);
+        order.setOrderType(Enums.OrderType.ACTIVATION);
+
+        Client client = new Client();
+        client.setId(1L);
+        client.setEmail("test@example.com");
+        client.setFirstName("Jan");
+        client.setLastName("Kowalski");
+
+        Notice notice = new Notice();
+        notice.setTitle("Test Notice");
+
+        order.setClient(client);
+        order.setNotice(notice);
+
+        OAuthPaymentResponseDTO oAuthResponse = new OAuthPaymentResponseDTO();
+        oAuthResponse.setAccess_token("testAccessToken");
+
+        when(orderService.getOrderById(orderId)).thenReturn(order);
+        when(paymentService.getOAuthToken()).thenReturn(oAuthResponse);
+        when(paymentService.createTransaction(eq(order), eq("testAccessToken"), any(TransactionPaymentRequestDTO.class)))
+                .thenReturn("http://payment.url");
+
+        ResponseEntity<?> response = orderController.fetchToken(orderId);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
+        assertEquals("http://payment.url", response.getBody(), "Ciało odpowiedzi powinno zawierać URL płatności");
+
+        System.out.println("Test pobierania tokena płatności przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania wszystkich zamówień")
+    public void testGetAllOrders() {
+        Long clientId = 1L;
+        Order order1 = new Order();
+        order1.setId(1L);
+        order1.setOrderType(Enums.OrderType.ACTIVATION);
+        order1.setStatus(Enums.OrderStatus.PENDING);
+        order1.setAmount(10.00);
+        order1.setCreatedAt(LocalDateTime.now());
+
+        Order order2 = new Order();
+        order2.setId(2L);
+        order2.setOrderType(Enums.OrderType.BOOST);
+        order2.setStatus(Enums.OrderStatus.COMPLETED);
+        order2.setAmount(8.00);
+        order2.setCreatedAt(LocalDateTime.now());
+
+        List<Order> orders = List.of(order1, order2);
+
+        Payment payment1 = new Payment();
+        payment1.setIdPayment(1L);
+        payment1.setAmount(10.00);
+        payment1.setStatus(Enums.PaymentStatus.PENDING);
+        payment1.setTransactionPaymentUrl("http://payment.url/1");
+        payment1.setTransactionId("trans1");
+
+        Payment payment2 = new Payment();
+        payment2.setIdPayment(2L);
+        payment2.setAmount(8.00);
+        payment2.setStatus(Enums.PaymentStatus.CORRECT);
+        payment2.setTransactionPaymentUrl("http://payment.url/2");
+        payment2.setTransactionId("trans2");
+
+        when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
+        when(orderService.getOrdersByClientId(clientId)).thenReturn(orders);
+        when(paymentService.getPaymentsByOrderId(1L)).thenReturn(List.of(payment1));
+        when(paymentService.getPaymentsByOrderId(2L)).thenReturn(List.of(payment2));
+
+        ResponseEntity<List<OrderWithPaymentsDTO>> response = orderController.getOrders(request);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
+        List<OrderWithPaymentsDTO> dtoList = response.getBody();
+        assertNotNull(dtoList, "Lista DTO nie powinna być null");
+        assertEquals(2, dtoList.size(), "Lista DTO powinna zawierać 2 elementy");
+
+        OrderWithPaymentsDTO dto1 = dtoList.getFirst();
+        assertEquals(1L, dto1.getOrderId(), "ID zamówienia w DTO powinno być 1");
+        assertEquals("ACTIVATION", dto1.getOrderType(), "Typ zamówienia w DTO powinien być ACTIVATION");
+        assertEquals("PENDING", dto1.getStatus(), "Status zamówienia w DTO powinien być PENDING");
+        assertEquals(10.00, dto1.getAmount(), "Kwota zamówienia w DTO powinna być 10.00");
+        assertEquals(1, dto1.getPayments().size(), "Liczba płatności w DTO powinna być 1");
+
+        System.out.println("Test pobierania wszystkich zamówień przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania zamówienia po ID")
+    public void testGetOrderById() {
+        Long clientId = 1L;
+        Long orderId = 1L;
+
+        Order order = new Order();
+        order.setId(orderId);
+        order.setOrderType(Enums.OrderType.ACTIVATION);
+        order.setStatus(Enums.OrderStatus.PENDING);
+        order.setAmount(10.00);
+        order.setCreatedAt(LocalDateTime.now());
+
+        Client client = new Client();
+        client.setId(clientId);
+        order.setClient(client);
+
+        Payment payment = new Payment();
+        payment.setIdPayment(1L);
+        payment.setAmount(10.00);
+        payment.setStatus(Enums.PaymentStatus.PENDING);
+        payment.setTransactionPaymentUrl("http://payment.url/1");
+        payment.setTransactionId("trans1");
+
+        when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
+        when(orderService.getOrderById(orderId)).thenReturn(order);
+        when(paymentService.getPaymentsByOrderId(orderId)).thenReturn(List.of(payment));
+
+        ResponseEntity<OrderWithPaymentsDTO> response = orderController.getOrderById(request, orderId);
+
+        assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
+        OrderWithPaymentsDTO dto = response.getBody();
+        assertNotNull(dto, "DTO nie powinno być null");
+        assertEquals(orderId, dto.getOrderId(), "ID zamówienia w DTO powinno być równe podanemu");
+
+        System.out.println("Test pobierania zamówienia po ID przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania zamówienia po ID - brak uprawnień")
+    public void testGetOrderByIdForbidden() {
+        Long clientId = 1L;
+        Long orderId = 1L;
+
+        Order order = new Order();
+        order.setId(orderId);
+        order.setOrderType(Enums.OrderType.ACTIVATION);
+        order.setStatus(Enums.OrderStatus.PENDING);
+        order.setAmount(10.00);
+        order.setCreatedAt(LocalDateTime.now());
+
+        Client client = new Client();
+        client.setId(2L);
+        order.setClient(client);
+
+        when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
+        when(orderService.getOrderById(orderId)).thenReturn(order);
+
+        ResponseEntity<OrderWithPaymentsDTO> response = orderController.getOrderById(request, orderId);
+
+        assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode(), "Status odpowiedzi powinien być 403 FORBIDDEN");
+
+        System.out.println("Test pobierania zamówienia po ID - brak uprawnień przeszedł pomyślnie.");
+    }
+}

src/test/java/_11/asktpk/artisanconnectbackend/OrderServiceTest.java

@@ -0,0 +1,123 @@
+package _11.asktpk.artisanconnectbackend;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import _11.asktpk.artisanconnectbackend.dto.OrderDTO;
+import _11.asktpk.artisanconnectbackend.entities.Client;
+import _11.asktpk.artisanconnectbackend.entities.Notice;
+import _11.asktpk.artisanconnectbackend.entities.Order;
+import _11.asktpk.artisanconnectbackend.repository.ClientRepository;
+import _11.asktpk.artisanconnectbackend.repository.NoticeRepository;
+import _11.asktpk.artisanconnectbackend.repository.OrderRepository;
+import _11.asktpk.artisanconnectbackend.service.OrderService;
+import _11.asktpk.artisanconnectbackend.utils.Enums;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class OrderServiceTest {
+
+    private final OrderRepository orderRepository = Mockito.mock(OrderRepository.class);
+    private final ClientRepository clientRepository = Mockito.mock(ClientRepository.class);
+    private final NoticeRepository noticeRepository = Mockito.mock(NoticeRepository.class);
+    private final OrderService orderService = new OrderService(orderRepository, clientRepository, noticeRepository);
+
+    @Test
+    @DisplayName("Test dodawania zamówienia")
+    public void testAddOrder() {
+        OrderDTO orderDTO = new OrderDTO();
+        orderDTO.setClientId(1L);
+        orderDTO.setNoticeId(1L);
+        orderDTO.setOrderType(Enums.OrderType.ACTIVATION);
+
+        Client client = new Client();
+        client.setId(1L);
+
+        Notice notice = new Notice();
+        notice.setIdNotice(1L);
+
+        Order savedOrder = new Order();
+        savedOrder.setId(1L);
+        savedOrder.setClient(client);
+        savedOrder.setNotice(notice);
+        savedOrder.setOrderType(Enums.OrderType.ACTIVATION);
+        savedOrder.setStatus(Enums.OrderStatus.PENDING);
+        savedOrder.setAmount(10.00);
+        savedOrder.setCreatedAt(LocalDateTime.now());
+        savedOrder.setUpdatedAt(LocalDateTime.now());
+
+        when(clientRepository.findById(1L)).thenReturn(Optional.of(client));
+        when(noticeRepository.findById(1L)).thenReturn(Optional.of(notice));
+        when(orderRepository.save(any(Order.class))).thenReturn(savedOrder);
+
+        Long orderId = orderService.addOrder(orderDTO);
+
+        assertNotNull(orderId, "ID zamówienia nie powinno być null");
+        assertEquals(1L, orderId, "ID zamówienia powinno być równe 1");
+        verify(orderRepository, times(1)).save(any(Order.class));
+
+        System.out.println("Test dodawania zamówienia przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test zmiany statusu zamówienia")
+    public void testChangeOrderStatus() {
+        Long orderId = 1L;
+        Enums.OrderStatus newStatus = Enums.OrderStatus.COMPLETED;
+
+        Order existingOrder = new Order();
+        existingOrder.setId(orderId);
+        existingOrder.setStatus(Enums.OrderStatus.PENDING);
+
+        when(orderRepository.findById(orderId)).thenReturn(Optional.of(existingOrder));
+        when(orderRepository.save(any(Order.class))).thenReturn(existingOrder);
+
+        Long updatedOrderId = orderService.changeOrderStatus(orderId, newStatus);
+
+        assertNotNull(updatedOrderId, "ID zaktualizowanego zamówienia nie powinno być null");
+        assertEquals(orderId, updatedOrderId, "ID zaktualizowanego zamówienia powinno być równe podanemu");
+        assertEquals(newStatus, existingOrder.getStatus(), "Status zamówienia powinien zostać zaktualizowany");
+        verify(orderRepository, times(1)).save(existingOrder);
+
+        System.out.println("Test zmiany statusu zamówienia przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania zamówienia po ID")
+    public void testGetOrderById() {
+        Long orderId = 1L;
+        Order order = new Order();
+        order.setId(orderId);
+
+        when(orderRepository.findById(orderId)).thenReturn(Optional.of(order));
+
+        Order retrievedOrder = orderService.getOrderById(orderId);
+
+        assertNotNull(retrievedOrder, "Pobrane zamówienie nie powinno być null");
+        assertEquals(orderId, retrievedOrder.getId(), "ID pobranego zamówienia powinno być równe podanemu");
+
+        System.out.println("Test pobierania zamówienia po ID przeszedł pomyślnie.");
+    }
+
+    @Test
+    @DisplayName("Test pobierania zamówień po ID klienta")
+    public void testGetOrdersByClientId() {
+        Long clientId = 1L;
+        List<Order> orders = List.of(new Order(), new Order());
+
+        when(orderRepository.findByClientId(clientId)).thenReturn(orders);
+
+        List<Order> retrievedOrders = orderService.getOrdersByClientId(clientId);
+
+        assertNotNull(retrievedOrders, "Lista zamówień nie powinna być null");
+        assertEquals(2, retrievedOrders.size(), "Lista zamówień powinna zawierać 2 elementy");
+
+        System.out.println("Test pobierania zamówień po ID klienta przeszedł pomyślnie.");
+    }
+}

src/test/java/_11/asktpk/artisanconnectbackend/ToolsTest.java

@@ -0,0 +1,40 @@
+package _11.asktpk.artisanconnectbackend;
+
+import _11.asktpk.artisanconnectbackend.security.JwtUtil;
+import _11.asktpk.artisanconnectbackend.utils.Tools;
+import jakarta.servlet.http.HttpServletRequest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ToolsTest {
+
+    @Mock
+    private JwtUtil jwtUtil;
+
+    @Mock
+    private HttpServletRequest request;
+
+    @InjectMocks
+    private Tools tools;
+
+    @Test
+    void getClientIdFromRequest_shouldReturnClientIdWhenTokenValid() {
+        String token = "valid.token.here";
+        Long expectedClientId = 1L;
+
+        when(request.getHeader("Authorization")).thenReturn("Bearer " + token);
+        when(jwtUtil.extractUserId(token)).thenReturn(expectedClientId);
+
+        Long result = tools.getClientIdFromRequest(request);
+
+        assertEquals(expectedClientId, result);
+    }
+
+}