Add Unit test LoggingFilter

src/main/java/eu/europa/ec/simpl/tlsgateway/filters/LoggingFilter.java

@@ -54,7 +54,12 @@ public class LoggingFilter implements GlobalFilter, Ordered {
         return loggingRule -> new BusinessLogger(loggingRule.config(), exchange, chain);
     }
 
-    private class BusinessLogger {
+    protected BusinessLogger newBusinessLogger(
+            LoggingRule.Config config, ServerWebExchange exchange, GatewayFilterChain chain) {
+        return new BusinessLogger(config, exchange, chain);
+    }
+
+    protected class BusinessLogger {
 
         private final LoggingRule.Config config;
         private final ServerWebExchange exchange;

src/test/java/eu/europa/ec/simpl/tlsgateway/filters/LoggingFilterTest.java

+package eu.europa.ec.simpl.tlsgateway.filters;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.when;
+
+import eu.europa.ec.simpl.common.model.dto.CredentialDTO;
+import eu.europa.ec.simpl.tlsgateway.configurations.LoggingRule;
+import eu.europa.ec.simpl.tlsgateway.configurations.security.RouteConfig;
+import eu.europa.ec.simpl.tlsgateway.utils.ExchangeUtil;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.util.Base64;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.cloud.gateway.filter.GatewayFilterChain;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+
+@ExtendWith(MockitoExtension.class)
+public class LoggingFilterTest {
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private CredentialDTO myPublicKey;
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private RouteConfig routeConfig;
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private LoggingRule loggingRule;
+
+    private LoggingFilter loggingFilter;
+
+    @BeforeEach
+    public void init() {
+        var loggingsRules = List.of(loggingRule);
+        when(routeConfig.logging().business()).thenReturn(loggingsRules);
+        loggingFilter = new LoggingFilter(myPublicKey, routeConfig);
+    }
+
+    @Test
+    public void filter_whenRuleDoesNotMatch_thenDoesNotThrow() {
+        var exchange = mock(ServerWebExchange.class);
+        var chain = mock(GatewayFilterChain.class);
+        when(loggingRule.matches(exchange)).thenReturn(Mono.just(true));
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        assertDoesNotThrow(() -> loggingFilter.filter(exchange, chain));
+    }
+
+    @Test
+    public void businessLoggerLogTest() throws NoSuchAlgorithmException {
+        LoggingRule.Config config = mock(LoggingRule.Config.class);
+        ServerWebExchange exchange = mock(ServerWebExchange.class, Answers.RETURNS_DEEP_STUBS);
+        var request = mock(ServerHttpRequest.class, Answers.RETURNS_DEEP_STUBS);
+        when(exchange.getRequest()).thenReturn(request);
+        when(request.getMethod()).thenReturn(HttpMethod.GET);
+        when(request.getPath().value()).thenReturn("http://junit/path");
+        GatewayFilterChain chain = mock(GatewayFilterChain.class);
+        var headers = new HttpHeaders();
+        headers.set("authentication", "Bearer token");
+        when(exchange.getRequest().getHeaders()).thenReturn(headers);
+
+        var keyPair = KeyPairGenerator.getInstance("RSA").genKeyPair();
+        var pubBase64 = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
+        when(myPublicKey.getPublicKey()).thenReturn(pubBase64);
+        var businessLogger = loggingFilter.newBusinessLogger(config, exchange, chain);
+        when(chain.filter(exchange)).thenReturn(Mono.empty());
+        try (var exchangeUtil = mockStatic(ExchangeUtil.class)) {
+            when(ExchangeUtil.getCredentialIdFromExchange(exchange)).thenReturn("junit-destination");
+            businessLogger.log();
+        }
+    }
+}