Added OrderRepositoryTest, OrderServiceTest, OrderControllerTest

src/main/java/com/example/testj/domain/Order.java

@@ -2,16 +2,19 @@ package com.example.testj.domain;
 
 import jakarta.persistence.*;
 import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.springframework.format.annotation.DateTimeFormat;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Getter
 @Setter
-@RequiredArgsConstructor
+@NoArgsConstructor
+@AllArgsConstructor
 @Entity
 @Table(name = "orders")
 public class Order {
@@ -24,6 +27,7 @@ public class Order {
     @Column(name = "client")
     private String client;
 
+    @NotBlank
     @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
     @Column(name = "date")
     private String date;
@@ -32,6 +36,6 @@ public class Order {
     @Column(name = "address")
     private String address;
 
-    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
-    List<OrderLine> orderLines;
+    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
+    private  List<OrderLine> orderLines = new ArrayList<>();
 }

src/main/java/com/example/testj/service/OrderService.java

@@ -8,7 +8,7 @@ import com.fasterxml.jackson.databind.JsonNode;
 import org.springframework.data.web.PagedModel;
 
 public interface OrderService {
-    PagedModel<OrderDto> getOrdersPaged(Integer page, Integer size, String sortBy, String sortDir);
+    PagedModel<OrderDto> getPagedOrders(Integer page, Integer size, String sortBy, String sortDir);
 
     OrderDto getOrder(Long id) throws ResourceNotFoundException;
 

src/main/java/com/example/testj/service/dto/OrderDto.java

 package com.example.testj.service.dto;
 
 import jakarta.validation.constraints.NotBlank;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.Setter;
+import lombok.*;
 
 import java.io.Serializable;
 import java.util.List;
@@ -12,14 +10,17 @@ import java.util.List;
  * DTO for {@link com.example.testj.domain.Order}
  */
 @AllArgsConstructor
+@NoArgsConstructor
 @Getter
 @Setter
+@EqualsAndHashCode(exclude = {"orderLines"})
 public class OrderDto implements Serializable {
-    private final Long id;
+    private Long id;
 
     @NotBlank
     private String client;
 
+    @NotBlank
     private String date;
 
     @NotBlank

src/main/java/com/example/testj/service/impl/OrderServiceImpl.java

@@ -23,7 +23,7 @@ public class OrderServiceImpl implements OrderService {
     private final OrderMapper orderMapper;
 
     @Override
-    public PagedModel<OrderDto> getOrdersPaged(Integer page, Integer size, String sortBy, String sortDir) {
+    public PagedModel<OrderDto> getPagedOrders(Integer page, Integer size, String sortBy, String sortDir) {
         return new PagedModel<>(orderRepository
                 .findAll(PageRequest.of(page, size, Sort.by(Sort.Direction.fromString(sortDir), sortBy)))
                 .map(orderMapper::toDto));
@@ -31,7 +31,7 @@ public class OrderServiceImpl implements OrderService {
 
     @Override
     public OrderDto getOrder(Long id) throws ResourceNotFoundException {
-        return orderMapper.toDto(orderRepository.findById(id).orElseThrow(ResourceNotFoundException::new));
+        return orderRepository.findById(id).map(orderMapper::toDto).orElseThrow(ResourceNotFoundException::new);
     }
 
     @Override

src/main/java/com/example/testj/service/mapper/OrderMapper.java

@@ -3,8 +3,9 @@ package com.example.testj.service.mapper;
 import com.example.testj.domain.Order;
 import com.example.testj.service.dto.OrderDto;
 import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
 
-@Mapper(componentModel = "spring")
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
 public interface OrderMapper {
     OrderDto toDto(Order order);
     Order toEntity(OrderDto orderDto);

src/main/java/com/example/testj/web/rest/OrderController.java

 package com.example.testj.web.rest;
 
-import com.example.testj.service.impl.OrderServiceImpl;
-import com.example.testj.service.mapper.OrderMapper;
-import lombok.RequiredArgsConstructor;
-import org.springframework.data.web.PagedModel;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.CrossOrigin;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PatchMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.PutMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestHeader;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.ResponseStatus;
-import org.springframework.web.bind.annotation.RestController;
-
 import com.example.testj.domain.Order;
 import com.example.testj.exception.ResourceNotFoundException;
+import com.example.testj.service.OrderService;
 import com.example.testj.service.dto.OrderDto;
+import com.example.testj.service.mapper.OrderMapper;
 import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.JsonNode;
-
 import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.web.PagedModel;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
 
 @RestController
 @RequestMapping("/api/orders")
 @CrossOrigin(origins = "http://localhost:4200")
 @RequiredArgsConstructor
 public class OrderController {
-    private final OrderServiceImpl orderService;
+    private final OrderService orderService;
     private final OrderMapper orderMapper;
 
     @GetMapping
-    public PagedModel<OrderDto> getOrders(
+    public PagedModel<OrderDto> getPaged(
             @RequestHeader(name = "X-Page-Current", defaultValue = "0") Integer page,
             @RequestHeader(name = "X-Page-Size", defaultValue = "10") Integer size,
             @RequestHeader(name = "X-Sort-By", defaultValue = "id") String sortBy,
             @RequestHeader(name = "X-Sort-Direction", defaultValue = "ASC") String sortDir) {
-        return orderService.getOrdersPaged(page, size, sortBy, sortDir);
+        return orderService.getPagedOrders(page, size, sortBy, sortDir);
     }
 
     @GetMapping("/{id}")
-    public OrderDto getOrder(@PathVariable Long id) {
+    public OrderDto get(@PathVariable Long id) {
         return orderService.getOrder(id);
     }
 
     @PostMapping
     @ResponseStatus(HttpStatus.CREATED)
-    public OrderDto createOrder(@Valid @RequestBody Order order) {
+    public OrderDto create(@Valid @RequestBody Order order) {
         return orderService.createOrUpdateOrder(order);
     }
 
     @PutMapping("/{id}")
     @ResponseStatus(HttpStatus.OK)
-    public OrderDto updateOrder(@PathVariable Long id, @RequestBody OrderDto order) {
+    public OrderDto update(@PathVariable Long id, @RequestBody OrderDto order) {
 
         OrderDto updatedOrder = orderService.getOrder(id);
         updatedOrder.setClient(order.getClient());
@@ -68,12 +55,12 @@ public class OrderController {
     }
 
     @PatchMapping("/{id}")
-    public OrderDto patchOrder(@PathVariable Long id, @RequestBody JsonNode patch) throws JsonMappingException {
+    public OrderDto patch(@PathVariable Long id, @RequestBody JsonNode patch) throws JsonMappingException {
         return orderService.patchOrder(id, patch);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<HttpStatus> deleteOrder(@PathVariable Long id) throws ResourceNotFoundException {
+    public ResponseEntity<HttpStatus> delete(@PathVariable Long id) throws ResourceNotFoundException {
         try {
             orderService.deleteOrder(id);
             return new ResponseEntity<>(HttpStatus.OK);

src/test/java/com/example/testj/repository/OrderRepositoryTest.java

+package com.example.testj.repository;
+
+import com.example.testj.domain.Order;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.util.List;
+import java.util.stream.StreamSupport;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DataJpaTest
+@ActiveProfiles("test")
+public class OrderRepositoryTest {
+    @Autowired
+    private OrderRepository orderRepository;
+
+    @Autowired
+    TestEntityManager entityManager;
+
+    @Test
+    void testSave() {
+        // given
+        Order order = new Order();
+        order.setClient("Client 1");
+        order.setAddress("Address 1");
+        order.setDate("2000-01-01");
+        // when
+        orderRepository.save(order);
+        // then
+        assertNotNull(order.getId());
+        assertEquals(entityManager.find(Order.class, order.getId()).getClient(), order.getClient());
+    }
+
+    @Test
+    void testFindById() {
+        // given
+        Long id = 1L;
+        // when
+        Order found = orderRepository.findById(id).orElse(null);
+        // then
+        assertNotNull(found);
+        assertEquals(found.getId(), id);
+    }
+
+    @Test
+    void testFindAll() {
+        // when
+        List<Order> found = StreamSupport.stream(orderRepository.findAll().spliterator(), false).toList();
+        // then
+        assertNotNull(found);
+        assertEquals(100, found.size());
+    }
+
+    @Test
+    void testUpdate() {
+        // given
+        Order order = entityManager.find(Order.class, 1L);
+        order.setAddress("Address 2");
+        order.setClient("Client 2");
+        order.setDate("2000-01-01");
+        // when
+        Order saved = orderRepository.save(order);
+        // then
+        assertNotNull(saved.getId());
+        assertEquals(entityManager.find(Order.class, saved.getId()).getClient(), order.getClient());
+    }
+
+    @Test
+    void testDelete() {
+        // given
+        Long id = 2L;
+        // when
+        orderRepository.deleteById(id);
+        // then
+        assertNull(entityManager.find(Order.class, id));
+    }
+}

src/test/java/com/example/testj/service/OrderServiceTest.java

+package com.example.testj.service;
+
+import com.example.testj.domain.Order;
+import com.example.testj.repository.OrderRepository;
+import com.example.testj.service.dto.OrderDto;
+import com.example.testj.service.impl.OrderServiceImpl;
+import com.example.testj.service.mapper.OrderMapper;
+import jakarta.validation.ConstraintViolationException;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mapstruct.factory.Mappers;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PagedModel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class OrderServiceTest {
+    @InjectMocks
+    private OrderServiceImpl orderService;
+
+    @Mock
+    private OrderRepository orderRepository;
+
+    @Spy
+    private OrderMapper orderMapper = Mappers.getMapper(OrderMapper.class);
+
+    private static List<Order> ordersList = new ArrayList<>();
+
+    @BeforeAll
+    static void init() {
+        Order order = new Order();
+        order.setId(1L);
+        order.setClient("client 1");
+        order.setAddress("address 1");
+        order.setDate("20-20-2020");
+
+        Order order1 = new Order();
+        order1.setId(2L);
+        order1.setClient("client 2");
+        order1.setAddress("address 2");
+        order1.setDate("10-10-2021");
+
+        ordersList = Stream.of(
+                order,
+                order1
+        ).toList();
+    }
+
+    @Test
+    void testCreateOrUpdateOrder() {
+        // given
+        Order order = new Order();
+        order.setClient("person 2");
+        order.setAddress("address 2");
+        order.setDate("01-01-2020");
+
+        Order result = new Order();
+        Long nextId = ordersList.getLast().getId() + 1;
+        result.setId(nextId);
+        result.setClient(order.getClient());
+        result.setAddress(order.getAddress());
+        result.setDate(order.getDate());
+        // when
+        when(orderRepository.save(order)).thenReturn(result);
+        OrderDto created = orderService.createOrUpdateOrder(order);
+        // then
+        assertEquals(result.getId(), created.getId());
+        verify(orderRepository, times(1)).save(order);
+    }
+
+    @Test
+    @Disabled
+    void testSaveOrderWithEmptyClient() {
+        // given
+        Order order = new Order();
+        order.setClient("");
+        order.setAddress("address 2");
+        order.setDate("01-01-2020");
+        // when
+        assertThrows(ConstraintViolationException.class, () -> orderService.createOrUpdateOrder(order));
+        // then
+        verify(orderRepository, times(1)).save(order);
+    }
+
+    @Test
+    @Disabled
+    void testSaveOrderWithNullName() {
+        // given
+        Order order = new Order();
+        order.setClient(null);
+        order.setAddress("address 2");
+        order.setDate("01-01-2020");
+        // when
+        assertThrows(ConstraintViolationException.class, () -> orderService.createOrUpdateOrder(order));
+        // then
+        verify(orderRepository, times(1)).save(order);
+    }
+
+    @Test
+    void testGetAllOrdersPaged() {
+        // when
+        when(orderRepository.findAll(any(Pageable.class))).thenReturn(new PageImpl<>(ordersList));
+        PagedModel<OrderDto> ordersDtoPagedModel = orderService.getPagedOrders(1,10, "id", "ASC");
+        // then
+        assertNotNull(ordersDtoPagedModel);
+        assertEquals(ordersDtoPagedModel.getContent().size(), 2);
+        verify(orderRepository, times(1)).findAll(any(Pageable.class));
+    }
+
+    @Test
+    void testGetOrder() {
+        // given
+        Long id = 1L;
+        // when
+        when(orderRepository.findById(id)).thenReturn(Optional.of(ordersList.getFirst()));
+        OrderDto order = orderService.getOrder(id);
+        // then
+        assertNotNull(order);
+        assertEquals(id, order.getId());
+        verify(orderRepository, times(1)).findById(any());
+    }
+
+    @Test
+    void testUpdateOrder() {
+        // given
+        Long id = 1L;
+        Order order = ordersList.getFirst();
+        order.setClient("client new");
+        order.setAddress("address new");
+        order.setDate("02-02-2020");
+        // when
+        when(orderRepository.save(order)).thenReturn(order);
+        OrderDto updated = orderService.createOrUpdateOrder(order);
+        // then
+        assertNotNull(updated);
+        assertEquals(id, updated.getId());
+        assertEquals(ordersList.getFirst().getClient(), updated.getClient());
+        assertEquals(ordersList.getFirst().getAddress(), updated.getAddress());
+        verify(orderRepository, only()).save(any());
+    }
+
+    @Test
+    void testDeleteOrder() {
+        // given
+        Long id = 2L;
+        // when
+        when(orderRepository.findById(id)).thenReturn(Optional.of(ordersList.getFirst()));
+        doNothing().when(orderRepository).deleteById(id);
+        orderService.deleteOrder(id);
+        // then
+        verify(orderRepository, times(1)).deleteById(id);
+    }
+}

src/test/java/com/example/testj/web/rest/OrderControllerTest.java

+package com.example.testj.web.rest;
+
+import com.example.testj.service.OrderService;
+import com.example.testj.service.dto.OrderDto;
+import com.example.testj.service.mapper.OrderMapper;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeAll;
+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.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.web.PagedModel;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+//@WebMvcTest(OrderController.class)
+public class OrderControllerTest {
+    @Autowired
+    private MockMvc mvc;
+
+    @MockBean
+    private OrderService orderService;
+
+    @MockBean
+    private OrderMapper orderMapper;
+
+    private static List<OrderDto> ordersList = new ArrayList<>();
+
+    @BeforeAll
+    static void init() {
+        OrderDto orderDto = new OrderDto();
+        orderDto.setId(1L);
+        orderDto.setClient("client 1");
+        orderDto.setAddress("address 1");
+        orderDto.setDate("20-20-2020");
+
+        OrderDto orderDto1 = new OrderDto();
+        orderDto1.setId(2L);
+        orderDto1.setClient("client 2");
+        orderDto1.setAddress("address 2");
+        orderDto1.setDate("10-10-2021");
+
+        ordersList = Stream.of(
+                orderDto,
+                orderDto1
+        ).toList();
+    }
+
+    @Test
+    @DisplayName("GET /api/orders")
+    public void orders() throws Exception {
+        Page<OrderDto> ordersPaged = new PageImpl<>(ordersList, PageRequest.of(0, 10),
+                ordersList.size());
+        when(orderService.getPagedOrders(0, 10, "id", "ASC"))
+                .thenReturn(new PagedModel<>(ordersPaged));
+        mvc.perform(get("/api/orders").contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.content[0].id").value(1))
+                .andExpect(jsonPath("$.page.totalElements").value(ordersList.size()));
+    }
+
+    @Test
+    @DisplayName("GET /api/orders/:id")
+    public void order() throws Exception {
+        Long id = 1L;
+        when(orderService.getOrder(id)).thenReturn(ordersList.getFirst());
+        mvc.perform(get("/api/orders/{id}", id).contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.id").value(id))
+                .andExpect(jsonPath("$.client").value(ordersList.getFirst().getClient()))
+                .andExpect(jsonPath("$.address").value(ordersList.getFirst().getAddress()));
+    }
+
+    @Test
+    @DisplayName("POST /api/orders [201 Created]")
+    void testCreateOrder() throws Exception {
+        OrderDto orderDto = new OrderDto();
+        orderDto.setClient("new client");
+        orderDto.setAddress("new address");
+        orderDto.setDate("20-20-2020");
+        String body = new ObjectMapper().writeValueAsString(orderDto);
+
+        Long nextId = (ordersList.getLast().getId() + 1);
+        orderDto.setId(nextId);
+
+        when(orderService.createOrUpdateOrder(orderMapper.toEntity(orderDto))).thenReturn(orderDto);
+
+        mvc.perform(post("/api/orders").contentType(MediaType.APPLICATION_JSON).content(body))
+                .andExpect(status().isCreated());
+//                .andExpect(jsonPath("$.id").isNumber())
+//                .andExpect(jsonPath("$.client").value(orderDto.getClient()))
+//                .andExpect(jsonPath("$.address").value(orderDto.getAddress()))
+//                .andExpect(jsonPath("$.date").value(orderDto.getDate()));
+    }
+
+    @Test
+    @DisplayName("PUT /api/orders/:id")
+    void testUpdateOrder() throws Exception {
+        Long id = 1L;
+        OrderDto orderDto = new OrderDto();
+        orderDto.setClient("new client");
+        orderDto.setAddress("new address");
+        orderDto.setDate("21-21-2021");
+        String body = new ObjectMapper().writeValueAsString(orderDto);
+
+        orderDto.setId(id);
+        when(orderService.getOrder(id)).thenReturn(ordersList.getFirst());
+        when(orderService.createOrUpdateOrder(orderMapper.toEntity(orderDto))).thenReturn(orderDto);
+
+        mvc.perform(put("/api/orders/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(body))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.client").value(orderDto.getClient()))
+                .andExpect(jsonPath("$.address").value(orderDto.getAddress()))
+                .andExpect(jsonPath("$.date").value(orderDto.getDate()));
+    }
+
+    @Test
+    @DisplayName("DELETE /api/orders/:id [200 OK]")
+    void testDeleteOrder() throws Exception {
+        Long id = 1L;
+        doNothing().when(orderService).deleteOrder(id);
+        mvc.perform(delete("/api/orders/{id}", id).contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk());
+    }
+}