RA-91: The error message has been expanded + UTs have been added (#163)

Author: Gennadii-T

api/src/main/java/org/cardanofoundation/rosetta/common/exception/GlobalExceptionHandler.java

@@ -3,55 +3,44 @@
 import java.util.List;
 import jakarta.servlet.http.HttpServletRequest;
 
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.validation.FieldError;
 import org.springframework.web.bind.MethodArgumentNotValidException;
-import org.springframework.web.bind.annotation.ControllerAdvice;
 import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 import org.cardanofoundation.rosetta.common.util.RosettaConstants.RosettaErrorType;
 
-@ControllerAdvice
+@RestControllerAdvice
 public class GlobalExceptionHandler {
 
-  @Value("${api.exception.isPrintStackTrace:true}")
-  private String isPrintStackTrace;
-
-
   @ExceptionHandler(Exception.class)
   public ResponseEntity<Error> handleGlobalException(Exception exception,
       HttpServletRequest request) {
-    printStackTraceIfNeeded(exception);
+
     Error errorResponse = RosettaErrorType.UNSPECIFIED_ERROR.toRosettaError(true,
         new Details("An error occurred for request " + request.getRequestId() + ": "
-                + exception.getMessage()));
+            + exception.getMessage()));
 
     return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
   }
 
   @ExceptionHandler(ApiException.class)
   public ResponseEntity<Error> handleApiException(ApiException apiException) {
-    printStackTraceIfNeeded(apiException);
     return new ResponseEntity<>(apiException.getError(), HttpStatus.INTERNAL_SERVER_ERROR);
   }
 
   @ExceptionHandler(MethodArgumentNotValidException.class)
   public ResponseEntity<Error> handleMethodArgumentNotValidException(
       MethodArgumentNotValidException methodArgumentNotValidException, HttpServletRequest request) {
-    printStackTraceIfNeeded(methodArgumentNotValidException);
+
     List<String> errors = methodArgumentNotValidException.getBindingResult().getFieldErrors()
-        .stream().map(FieldError::getDefaultMessage).toList();
+        .stream()
+        .map(error -> error.getField() + " " + error.getDefaultMessage())
+        .toList();
     Error errorResponse = RosettaErrorType.UNSPECIFIED_ERROR.toRosettaError(true,
         new Details("An error occurred for request " + request.getRequestId() + ": "
-                + errors));
+            + errors));
     return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
   }
-
-  private void printStackTraceIfNeeded(Exception exception) {
-    if (isPrintStackTrace.equals("true")) {
-      exception.printStackTrace();
-    }
-  }
 }

api/src/test/java/org/cardanofoundation/rosetta/common/exception/GlobalExceptionHandlerTest.java

@@ -0,0 +1,99 @@
+package org.cardanofoundation.rosetta.common.exception;
+
+import java.util.Collections;
+import jakarta.servlet.http.HttpServletRequest;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.BindingResult;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import org.cardanofoundation.rosetta.common.util.RosettaConstants.RosettaErrorType;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class GlobalExceptionHandlerTest {
+
+  private static final String TEST_ID = "1";
+  private static final Integer CARDANO_ERROR_CODE = 5000;
+  private static final String FIELD_NAME = "fieldName";
+  private static final String MISSING_FIELD_MESSAGE = "must be not null";
+  private static final String ARGUMENT_NOT_VALID_MESSAGE = FIELD_NAME + " " + MISSING_FIELD_MESSAGE;
+  private static final String GLOBAL_MESSAGE = "Global Exception";
+  private static final String API_MESSAGE = "API Exception";
+  private static final String GLOBAL_EXCEPTION_MESSAGE =
+      "An error occurred for request " + TEST_ID + ": " + GLOBAL_MESSAGE;
+  private static final String API_EXCEPTION_MESSAGE =
+      "An error occurred for request " + TEST_ID + ": " + API_MESSAGE;
+  private static final String ARGUMENT_NOT_VALID_EXCEPTION_MESSAGE =
+      "An error occurred for request " + TEST_ID + ": [" + ARGUMENT_NOT_VALID_MESSAGE + "]";
+
+  @Mock
+  private HttpServletRequest request;
+
+  @Mock
+  private MethodArgumentNotValidException methodArgumentNotValidException;
+
+  @Mock
+  private FieldError fieldError;
+
+  @Mock
+  private BindingResult bindingResult;
+
+  @InjectMocks
+  private GlobalExceptionHandler underTest;
+
+  @Test
+  void handleGlobalException_shouldReturnInternalServerError() {
+    Exception globalException = new Exception(GLOBAL_MESSAGE);
+
+    when(request.getRequestId()).thenReturn(TEST_ID);
+    ResponseEntity<Error> result = underTest.handleGlobalException(globalException, request);
+
+    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, result.getStatusCode());
+    assertEquals(GLOBAL_EXCEPTION_MESSAGE, result.getBody().getDetails().getMessage());
+    assertEquals(CARDANO_ERROR_CODE, result.getBody().getCode());
+  }
+
+  @Test
+  void handleAPIException_shouldReturnInternalServerError() {
+    ApiException apiException = createApiException();
+
+    ResponseEntity<Error> result = underTest.handleApiException(apiException);
+
+    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, result.getStatusCode());
+    assertEquals(apiException.getError().getDetails().getMessage(),
+        result.getBody().getDetails().getMessage());
+    assertEquals(apiException.getError().getCode(), result.getBody().getCode());
+  }
+
+  @Test
+  void handleMethodArgumentNotValidException_shouldReturnInternalServerError() {
+    when(methodArgumentNotValidException.getBindingResult()).thenReturn(bindingResult);
+    when(bindingResult.getFieldErrors()).thenReturn(Collections.singletonList(fieldError));
+    when(fieldError.getField()).thenReturn(FIELD_NAME);
+    when(fieldError.getDefaultMessage()).thenReturn(MISSING_FIELD_MESSAGE);
+    when(request.getRequestId()).thenReturn(TEST_ID);
+
+    ResponseEntity<Error> result = underTest.handleMethodArgumentNotValidException(
+        methodArgumentNotValidException, request);
+
+    assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, result.getStatusCode());
+    assertEquals(ARGUMENT_NOT_VALID_EXCEPTION_MESSAGE, result.getBody().getDetails().getMessage());
+    assertEquals(CARDANO_ERROR_CODE, result.getBody().getCode());
+  }
+
+  private ApiException createApiException() {
+    return new ApiException(RosettaErrorType.UNSPECIFIED_ERROR.toRosettaError(true,
+        new Details(API_EXCEPTION_MESSAGE)));
+  }
+}