Added some uncovered test

src/main/java/com/example/testj/exception/RestResponseEntityExceptionHandler.java

@@ -5,6 +5,7 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.HttpStatusCode;
 import org.springframework.http.ResponseEntity;
 import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.lang.NonNull;
 import org.springframework.web.bind.MethodArgumentNotValidException;
 import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
@@ -15,6 +16,7 @@ import java.time.format.DateTimeParseException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 @ControllerAdvice
@@ -24,19 +26,21 @@ public class RestResponseEntityExceptionHandler
     @ExceptionHandler({ DateTimeParseException.class })
 
     protected ResponseEntity<Object> handleMethodArgumentNotValid(
-            MethodArgumentNotValidException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
-        //Get all fields errors
+            @NonNull MethodArgumentNotValidException ex, @NonNull HttpHeaders headers, @NonNull HttpStatusCode status,
+            @NonNull WebRequest request) {
+        // Get all fields errors
         List<Map<String, String>> errors = ex.getBindingResult()
                 .getFieldErrors()
                 .stream()
-                .map(err -> Map.of("field", err.getField(), "message", err.getDefaultMessage()))
+                .map(err -> Map.of("field", err.getField(), "message", Objects.requireNonNull(err.getDefaultMessage())))
                 .collect(Collectors.toList());
         ApiError body = new ApiError(status, ex.getBody().getDetail(), errors);
         return handleExceptionInternal(ex, body, headers, status, request);
     }
 
     protected ResponseEntity<Object> handleHttpMessageNotReadable(
-            HttpMessageNotReadableException ex, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
+            @NonNull HttpMessageNotReadableException ex, @NonNull HttpHeaders headers, @NonNull HttpStatusCode status,
+            @NonNull WebRequest request) {
         ApiError body = new ApiError(HttpStatus.BAD_REQUEST, ex.getMessage(), new ArrayList<>());
         return handleExceptionInternal(ex, body, headers, status, request);
     }

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

@@ -5,9 +5,10 @@ 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 com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
 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;
@@ -82,23 +83,23 @@ public class OrderServiceTest {
     }
 
     @Test
-    @Disabled
     void testSaveOrderWithEmptyClient() {
         // given
         Order order = new Order(null, "", LocalDate.of(2020, 1, 1), "address new", null);
         // when
-        assertThrows(ConstraintViolationException.class, () -> orderService.createOrUpdateOrder(order));
+        when(orderRepository.save(order)).thenThrow(IllegalArgumentException.class);
+        assertThrows(IllegalArgumentException.class, () -> orderService.createOrUpdateOrder(order));
         // then
         verify(orderRepository, times(1)).save(order);
     }
 
     @Test
-    @Disabled
     void testSaveOrderWithNullName() {
         // given
         Order order = new Order(null, null,  LocalDate.of(2020, 1, 1), "address", null);
         // when
-        assertThrows(ConstraintViolationException.class, () -> orderService.createOrUpdateOrder(order));
+        when(orderRepository.save(order)).thenThrow(IllegalArgumentException.class);
+        assertThrows(IllegalArgumentException.class, () -> orderService.createOrUpdateOrder(order));
         // then
         verify(orderRepository, times(1)).save(order);
     }
@@ -146,6 +147,25 @@ public class OrderServiceTest {
         verify(orderRepository, only()).save(any());
     }
 
+    @Test
+    void testPatchOrder() throws JsonProcessingException {
+        // given
+        Long id = 1L;
+        Order order = ordersList.getFirst();
+        JsonNode patch = new ObjectMapper().readTree("{\"client\": \"client patch\"}");
+        Order patchedOrder = new ObjectMapper().updateValue(order, patch);
+        // when
+        when(orderRepository.findById(id)).thenReturn(Optional.of(order));
+        when(orderRepository.save(patchedOrder)).thenReturn(patchedOrder);
+        OrderDto patched = orderService.patchOrder(id, patch);
+        // then
+        assertNotNull(patched);
+        assertEquals(id, patched.getId());
+        assertEquals(ordersList.getFirst().getClient(), patched.getClient());
+        assertEquals(ordersList.getFirst().getAddress(), patched.getAddress());
+        verify(orderRepository, times(1)).save(any());
+    }
+
     @Test
     void testDeleteOrder() {
         // given

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

@@ -148,7 +148,7 @@ public class GoodsControllerTest {
     @DisplayName("DELETE /api/goods/:id [404 Not Found]")
     void testDeleteGoodsNotFound() throws Exception {
         Long id = 999L;
-        doThrow(new ResourceNotFoundException()).doNothing().when(goodsService).deleteGoods(id);
+        doThrow(ResourceNotFoundException.class).doNothing().when(goodsService).deleteGoods(id);
         mvc.perform(delete("/api/goods/{id}", id))
                 .andExpect(status().isNotFound());
     }

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

 package com.example.testj.web.rest;
 
+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;
@@ -25,8 +26,7 @@ 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.mockito.Mockito.*;
 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;
@@ -137,6 +137,27 @@ public class OrderControllerTest {
                 .andExpect(jsonPath("$.date").value(orderDto.getDate().toString()));
     }
 
+    @Test
+    @DisplayName("PATCH /api/orders/:id [200 OK]")
+    void testPatchOrder() throws Exception {
+        Long id = 1L;
+        OrderDto orderDto = new OrderDto(
+                id, "client patch", ordersList.getFirst().getDate(), ordersList.getFirst().getAddress(),
+                ordersList.getFirst().getOrderLines());
+        String patch = objectMapper.writeValueAsString("{'name': 'client patch'}");
+
+        when(orderService.getOrder(id)).thenReturn(ordersList.getFirst());
+        when(orderService.patchOrder(id, objectMapper.readTree(patch))).thenReturn(orderDto);
+
+        mvc.perform(patch("/api/orders/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(patch))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.client").value(orderDto.getClient()))
+                .andExpect(jsonPath("$.address").value(orderDto.getAddress()))
+                .andExpect(jsonPath("$.date").value(orderDto.getDate().toString()));
+    }
+
     @Test
     @DisplayName("DELETE /api/orders/:id [200 OK]")
     void testDeleteOrder() throws Exception {
@@ -145,4 +166,13 @@ public class OrderControllerTest {
         mvc.perform(delete("/api/orders/{id}", id).contentType(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk());
     }
+
+    @Test
+    @DisplayName("DELETE /api/orders/:id [404 Not Found]")
+    void testDeleteOrderNotFound() throws Exception {
+        Long id = 999L;
+        doThrow(ResourceNotFoundException.class).doNothing().when(orderService).deleteOrder(id);
+        mvc.perform(delete("/api/orders/{id}", id).contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound());
+    }
 }

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

@@ -17,8 +17,7 @@ import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
 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;
@@ -104,4 +103,13 @@ public class OrderLineControllerTest {
         mvc.perform(delete("/api/order-line/{id}", id).contentType(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk());
     }
+
+    @Test
+    @DisplayName("DELETE /api/order-line/:id [404 Not Found]")
+    void testDeleteOrderLineNotFound() throws Exception {
+        Long id = 999L;
+        doThrow(ResourceNotFoundException.class).doNothing().when(orderLineService).deleteOrderLine(id);
+        mvc.perform(delete("/api/order-line/{id}", id).contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound());
+    }
 }