Add test for http exception handler

Signed-off-by: Tomas Longo <tomas.longo@sap.com>

Author: Tomas Longo

data-prepper-plugins/otel-trace-source/src/main/java/org/opensearch/dataprepper/plugins/source/oteltrace/grpc/GrpcService.java

@@ -19,7 +19,6 @@
 import org.opensearch.dataprepper.plugins.source.oteltrace.OTelTraceGrpcService;
 import org.opensearch.dataprepper.plugins.source.oteltrace.OTelTraceSourceConfig;
 import org.opensearch.dataprepper.plugins.source.oteltrace.RetryInfoConfig;
-import org.opensearch.dataprepper.plugins.source.oteltrace.certificate.CertificateProviderFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -84,7 +83,6 @@ public com.linecorp.armeria.server.grpc.GrpcService create(Buffer<Record<Object>
             grpcServiceBuilder.addService(ServerInterceptors.intercept(oTelTraceGrpcService, serverInterceptors));
         }
 
-        // todo tlongo extract into separate grpc config. Can't we have only one healthcheck for the whole server? We are already configuring one OtelTraceSource
         if (oTelTraceSourceConfig.hasHealthCheck()) {
             LOG.info("Health check is enabled");
             grpcServiceBuilder.addService(new HealthGrpcService());

data-prepper-plugins/otel-trace-source/src/main/java/org/opensearch/dataprepper/plugins/source/oteltrace/http/ArmeriaHttpService.java

@@ -108,9 +108,5 @@ private void processRequest(final ExportTraceServiceRequest request) {
         }
 
         successRequestsCounter.increment();
-
-        // todo tlongo what is the responseObserver used for?
-//        responseObserver.onNext(ExportTraceServiceResponse.newBuilder().build());
-//        responseObserver.onCompleted();
     }
 }

data-prepper-plugins/otel-trace-source/src/main/java/org/opensearch/dataprepper/plugins/source/oteltrace/http/HttpExceptionHandler.java

@@ -29,7 +29,6 @@
 import io.grpc.StatusRuntimeException;
 import io.micrometer.core.instrument.Counter;
 
-// todo tlongo add tests for metrics
 public class HttpExceptionHandler implements ExceptionHandlerFunction {
     private static final Logger LOG = LoggerFactory.getLogger(HttpExceptionHandler.class);
 
@@ -61,7 +60,6 @@ public HttpResponse handleException(final ServiceRequestContext ctx,
         StatusHolder statusHolder = createStatus(exceptionCause);
 
         try {
-            // todo tlongo why do we need this in the first place?
             JsonFormat.TypeRegistry typeRegistry = JsonFormat.TypeRegistry.newBuilder()
                     .add(RetryInfo.getDescriptor())
                     .build();

data-prepper-plugins/otel-trace-source/src/main/java/org/opensearch/dataprepper/plugins/source/oteltrace/http/HttpService.java

@@ -23,7 +23,6 @@
 
 public class HttpService {
     private static final Logger LOG = LoggerFactory.getLogger(HttpService.class);
-    // todo tlongo include in config
     private static final RetryInfoConfig DEFAULT_RETRY_INFO = new RetryInfoConfig(Duration.ofMillis(100), Duration.ofMillis(2000));
 
     private final PluginMetrics pluginMetrics;

data-prepper-plugins/otel-trace-source/src/test/java/org/opensearch/dataprepper/plugins/source/oteltrace/OTelTraceSource_HttpServiceTest.java

@@ -126,7 +126,7 @@ class OTelTraceSource_HttpServiceTest {
     private PipelineDescription pipelineDescription;
     private OTelTraceSource SOURCE;
 
-    private static HttpBasicAuthenticationConfig PROVIDED_CONFIG = new HttpBasicAuthenticationConfig("username", "password");
+    private static final HttpBasicAuthenticationConfig PROVIDED_CONFIG = new HttpBasicAuthenticationConfig("username", "password");
 
 
     @BeforeEach
@@ -175,6 +175,25 @@ private void configureObjectUnderTest() {
         SOURCE = new OTelTraceSource(oTelTraceSourceConfig, pluginMetrics, pluginFactory, pipelineDescription);
     }
 
+    @Test
+    void healthcheck_is_up() {
+        when(oTelTraceSourceConfig.enableHttpHealthCheck()).thenReturn(true);
+        SOURCE.start(buffer);
+
+        WebClient.of().execute(RequestHeaders.builder()
+                        .scheme(SessionProtocol.HTTP)
+                        .authority("127.0.0.1:21890")
+                        .method(HttpMethod.HEAD)
+                        .path("/health")
+                        .contentType(MediaType.JSON_UTF_8)
+                        .build())
+                .aggregate()
+                .whenComplete((response, throwable) -> assertThat(response.status(), is(HttpStatus.OK)))
+                .join();
+
+        verifyNoInteractions(buffer);
+    }
+
     @Test
     void request_fails_because_of_invalid_payload() throws Exception {
         ExportTraceServiceRequest request = createInvalidExportTraceRequest();

data-prepper-plugins/otel-trace-source/src/test/java/org/opensearch/dataprepper/plugins/source/oteltrace/http/HttpExceptionHandlerTest.java

@@ -0,0 +1,97 @@
+package org.opensearch.dataprepper.plugins.source.oteltrace.http;
+
+
+import java.time.Duration;
+import java.util.concurrent.TimeoutException;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.opensearch.dataprepper.HttpRequestExceptionHandler;
+import org.opensearch.dataprepper.exceptions.BadRequestException;
+import org.opensearch.dataprepper.exceptions.BufferWriteException;
+import org.opensearch.dataprepper.exceptions.RequestCancelledException;
+import org.opensearch.dataprepper.metrics.PluginMetrics;
+import org.opensearch.dataprepper.model.buffer.SizeOverflowException;
+
+import com.linecorp.armeria.common.HttpRequest;
+import com.linecorp.armeria.server.RequestTimeoutException;
+import com.linecorp.armeria.server.ServiceRequestContext;
+
+import io.micrometer.core.instrument.Counter;
+
+@ExtendWith(MockitoExtension.class)
+class HttpExceptionHandlerTest {
+    HttpExceptionHandler httpExceptionHandler;
+
+    @Mock
+    private PluginMetrics pluginMetrics;
+
+    @Mock
+    private ServiceRequestContext requestContext;
+
+    @Mock
+    private HttpRequest httpRequest;
+
+    @Mock
+    private Counter requestTimeoutsCounter;
+
+    @Mock
+    private Counter badRequestsCounter;
+
+    @Mock
+    private Counter requestsTooLargeCounter;
+
+    @Mock
+    private Counter internalServerErrorCounter;
+    @BeforeEach
+    public void setUp() {
+        when(pluginMetrics.counter(HttpRequestExceptionHandler.REQUEST_TIMEOUTS)).thenReturn(requestTimeoutsCounter);
+        when(pluginMetrics.counter(HttpRequestExceptionHandler.BAD_REQUESTS)).thenReturn(badRequestsCounter);
+        when(pluginMetrics.counter(HttpRequestExceptionHandler.REQUESTS_TOO_LARGE)).thenReturn(requestsTooLargeCounter);
+        when(pluginMetrics.counter(HttpRequestExceptionHandler.INTERNAL_SERVER_ERROR)).thenReturn(internalServerErrorCounter);
+        httpExceptionHandler = new HttpExceptionHandler(pluginMetrics, Duration.ofMillis(100), Duration.ofSeconds(2));
+    }
+
+    @Test
+    public void testHandleBadRequestException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, new BadRequestException("msg", null));
+        verify(badRequestsCounter).increment();
+    }
+
+    @Test
+    public void testHandleTimeoutException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, new BufferWriteException(null, new TimeoutException()));
+        verify(requestTimeoutsCounter, times(1)).increment();
+    }
+
+    @Test
+    public void testHandleArmeriaTimeoutException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, RequestTimeoutException.get());
+        verify(requestTimeoutsCounter, times(1)).increment();
+    }
+
+    @Test
+    public void testHandleSizeOverflowException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, new SizeOverflowException("msg"));
+        verify(requestsTooLargeCounter).increment();
+    }
+
+    @Test
+    public void testHandleRequestCancelledException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, new RequestCancelledException("msg"));
+        verify(requestTimeoutsCounter, times(1)).increment();
+    }
+
+    @Test
+    public void testHandleInternalServerException() {
+        httpExceptionHandler.handleException(requestContext, httpRequest, new RuntimeException("msg"));
+        verify(internalServerErrorCounter, times(1)).increment();
+    }
+}