#552 - Improve test coverage

- Improve coverage for terminology
- Improve coverage for dse/persistence
- Improve coverage for dse/api
- Improve coverage for WebSecurityConfig

Author: michael-82

src/main/java/de/numcodex/feasibility_gui_backend/terminology/persistence/Coding.java

@@ -11,14 +11,12 @@ public class Coding implements Serializable {
   private String code;
   private String version;
 
-  public Coding() {
-  }
-
   public Coding(String system, String code, String version) {
     requireNonNull(system);
     requireNonNull(code);
     this.system = system;
     this.code = code;
+    this.version = version;
   }
 
   @Override

src/test/java/de/numcodex/feasibility_gui_backend/common/api/TermCodeTest.java

@@ -34,5 +34,8 @@ public void testEqualsAndHashCode() {
 
         assertEquals(termCode1.hashCode(), termCode2.hashCode());
         assertNotEquals(termCode1.hashCode(), termCode3.hashCode());
+
+        assertNotEquals(termCode1, null);
+        assertNotEquals(termCode1, "");
     }
 }

src/test/java/de/numcodex/feasibility_gui_backend/config/WebSecurityConfigIT.java

@@ -48,7 +48,6 @@
     controllers = {DataqueryHandlerRestController.class,
         TerminologyRestController.class
     }
-
 )
 class WebSecurityConfigIT {
 

src/test/java/de/numcodex/feasibility_gui_backend/config/WebSecurityConfigSslIT.java

@@ -0,0 +1,84 @@
+package de.numcodex.feasibility_gui_backend.config;
+
+import de.numcodex.feasibility_gui_backend.query.dataquery.DataqueryHandler;
+import de.numcodex.feasibility_gui_backend.query.ratelimiting.AuthenticationHelper;
+import de.numcodex.feasibility_gui_backend.query.ratelimiting.RateLimitingServiceSpringConfig;
+import de.numcodex.feasibility_gui_backend.query.v5.DataqueryHandlerRestController;
+import de.numcodex.feasibility_gui_backend.terminology.TerminologyService;
+import de.numcodex.feasibility_gui_backend.terminology.es.TerminologyEsService;
+import de.numcodex.feasibility_gui_backend.terminology.v5.TerminologyRestController;
+import de.numcodex.feasibility_gui_backend.terminology.validation.StructuredQueryValidation;
+import org.hamcrest.Matchers;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.security.oauth2.jwt.JwtDecoder;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
+
+import java.net.URI;
+
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+// This is moved to a separate class to check if ssl enabled is correctly working
+@ExtendWith(SpringExtension.class)
+@Import({AuthenticationHelper.class,
+    RateLimitingServiceSpringConfig.class,
+    WebSecurityConfig.class
+})
+@WebMvcTest(
+    controllers = {DataqueryHandlerRestController.class,
+        TerminologyRestController.class
+    }
+)
+@TestPropertySource(properties = {
+    "server.ssl.enabled=true",
+    "server.ssl.key-store=classpath:keystore.p12",
+    "server.ssl.key-store-password=password",
+    "server.ssl.key-store-type=PKCS12",
+    "server.ssl.key-alias=tomcat"
+})
+class WebSecurityConfigSslIT {
+
+  @Autowired
+  private MockMvc mockMvc;
+
+  @MockitoBean
+  private JwtDecoder jwtDecoder;
+
+  @MockitoBean
+  private DataqueryHandler dataqueryHandler;
+
+  @MockitoBean
+  private StructuredQueryValidation structuredQueryValidation;
+
+  @MockitoBean
+  private TerminologyService terminologyService;
+
+  @MockitoBean
+  private TerminologyEsService terminologyEsService;
+
+  @Test
+  void shouldRedirectHttpToHttps() throws Exception {
+    mockMvc.perform(get(URI.create("/api/v5/query/data")).with(csrf()))
+        .andExpect(status().is3xxRedirection())
+        .andExpect(header().string("Location", Matchers.startsWith("https://")));
+  }
+
+  @Test
+  @WithMockUser(username = "user", roles = "DATAPORTAL_TEST_USER")
+  void shouldNotRedirectHttps() throws Exception {
+    mockMvc.perform(get(URI.create("https://localhost/api/v5/query/data")).with(csrf()))
+        .andExpect(status().isOk());
+  }
+
+}

src/test/java/de/numcodex/feasibility_gui_backend/config/WebSecurityConfigTest.java

@@ -0,0 +1,62 @@
+package de.numcodex.feasibility_gui_backend.config;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.oauth2.jwt.Jwt;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class WebSecurityConfigTest {
+
+  private static final String KEY_REALM_ACCESS = "realm_access";
+  private static final String KEY_RESOURCE_ACCESS = "resource_access";
+  private static final String KEY_ROLES = "roles";
+  private static final String KEY_SPRING_ADDONS_CONFIDENTIAL = "spring-addons-confidential";
+  private static final String KEY_SPRING_ADDONS_PUBLIC = "spring-addons-public";
+
+  @Test
+  void shouldExtractAllRolesFromJwt() {
+    Jwt jwt = mock(Jwt.class);
+
+    Map<String, Object> realmAccess = Map.of(
+        KEY_ROLES, List.of("role_realm1", "role_realm2")
+    );
+
+    Map<String, Object> confidentialAccess = Map.of(
+        KEY_ROLES, List.of("role_conf1")
+    );
+
+    Map<String, Object> publicAccess = Map.of(
+        KEY_ROLES, List.of("role_pub1", "role_pub2")
+    );
+
+    Map<String, Object> resourceAccess = Map.of(
+        KEY_SPRING_ADDONS_CONFIDENTIAL, confidentialAccess,
+        KEY_SPRING_ADDONS_PUBLIC, publicAccess
+    );
+
+    Map<String, Object> claims = Map.of(
+        KEY_REALM_ACCESS, realmAccess,
+        KEY_RESOURCE_ACCESS, resourceAccess
+    );
+
+    when(jwt.getClaims()).thenReturn(claims);
+
+    var converter = new WebSecurityConfig();
+    var authoritiesConverter = converter.authoritiesConverter();
+    List<GrantedAuthority> authorities = (List<GrantedAuthority>) authoritiesConverter.convert(jwt);
+
+
+    Assertions.assertNotNull(authorities);
+    List<String> roles = authorities.stream()
+        .map(GrantedAuthority::getAuthority)
+        .toList();
+
+    Assertions.assertEquals(List.of("role_realm1", "role_realm2", "role_conf1", "role_pub1", "role_pub2"), roles);
+  }
+}

src/test/java/de/numcodex/feasibility_gui_backend/dse/api/DseProfileTest.java

@@ -0,0 +1,69 @@
+package de.numcodex.feasibility_gui_backend.dse.api;
+
+import de.numcodex.feasibility_gui_backend.common.api.DisplayEntry;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DseProfileTest {
+
+  @Test
+  void testConstructorWithValues() {
+    DseProfile dseProfile = DseProfile.builder()
+        .url("url")
+        .display(DisplayEntry.builder().build())
+        .module(DisplayEntry.builder().build())
+        .fields(List.of(Field.builder().build()))
+        .filters(List.of(Filter.builder().build()))
+        .references(List.of(Reference.builder().build()))
+        .errorCode("error")
+        .errorCause("123")
+        .build();
+
+    assertNotNull(dseProfile);
+    assertNotNull(dseProfile.url());
+    assertNotNull(dseProfile.display());
+    assertNotNull(dseProfile.module());
+    assertNotNull(dseProfile.fields());
+    assertNotNull(dseProfile.filters());
+    assertNotNull(dseProfile.references());
+    assertNotNull(dseProfile.errorCode());
+    assertNotNull(dseProfile.errorCause());
+
+    assertNotEquals(dseProfile.fields(), Collections.emptyList());
+    assertNotEquals(dseProfile.filters(), Collections.emptyList());
+    assertNotEquals(dseProfile.references(), Collections.emptyList());
+  }
+
+  @Test
+  public void testConstructorWithNull() {
+    DseProfile dseProfile = DseProfile.builder()
+        .url("url")
+        .display(DisplayEntry.builder().build())
+        .module(DisplayEntry.builder().build())
+        .fields(null)
+        .filters(null)
+        .references(null)
+        .errorCode("error")
+        .errorCause("123")
+        .build();
+
+    assertNotNull(dseProfile);
+    assertNotNull(dseProfile.url());
+    assertNotNull(dseProfile.display());
+    assertNotNull(dseProfile.module());
+    assertNotNull(dseProfile.fields());
+    assertNotNull(dseProfile.filters());
+    assertNotNull(dseProfile.references());
+    assertNotNull(dseProfile.errorCode());
+    assertNotNull(dseProfile.errorCause());
+
+    assertEquals(dseProfile.fields(), Collections.emptyList());
+    assertEquals(dseProfile.filters(), Collections.emptyList());
+    assertEquals(dseProfile.references(), Collections.emptyList());
+  }
+
+}

src/test/java/de/numcodex/feasibility_gui_backend/dse/api/DseProfileTreeNodeTest.java

@@ -0,0 +1,63 @@
+package de.numcodex.feasibility_gui_backend.dse.api;
+
+import de.numcodex.feasibility_gui_backend.common.api.DisplayEntry;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DseProfileTreeNodeTest {
+
+  @Test
+  void testConstructorWithValues() {
+    DseProfileTreeNode childNode = DseProfileTreeNode.builder()
+        .id("childid")
+        .children(null)
+        .name(null)
+        .display(null)
+        .fields(null)
+        .module(null)
+        .url(null)
+        .leaf(false)
+        .selectable(false)
+        .build();
+
+    DseProfileTreeNode parentNode = DseProfileTreeNode.builder()
+        .id("id")
+        .children(List.of(childNode))
+        .name("name")
+        .display(DisplayEntry.builder().build())
+        .fields(FieldDisplayEntry.builder().build())
+        .module("module")
+        .url("http://url")
+        .leaf(true)
+        .selectable(true)
+        .build();
+
+    assertNotNull(parentNode);
+    assertNotNull(childNode);
+    assertNotEquals(Collections.emptyList(), parentNode.children());
+    assertEquals(childNode.id(), parentNode.children().get(0).id());
+  }
+
+  @Test
+  public void testConstructorWithNull() {
+    DseProfileTreeNode dseProfileTreeNode = DseProfileTreeNode.builder()
+        .id(null)
+        .children(null)
+        .name(null)
+        .display(null)
+        .fields(null)
+        .module(null)
+        .url(null)
+        .leaf(false)
+        .selectable(false)
+        .build();
+
+    assertNotNull(dseProfileTreeNode);
+    assertNotNull(dseProfileTreeNode.children());
+    assertEquals(Collections.emptyList(), dseProfileTreeNode.children());
+  }
+}

src/test/java/de/numcodex/feasibility_gui_backend/dse/api/FieldDisplayEntryTest.java

@@ -0,0 +1,45 @@
+package de.numcodex.feasibility_gui_backend.dse.api;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FieldDisplayEntryTest {
+
+  @Test
+  public void testConstructorWithValues() {
+    List<String> original = List.of("original-value1",  "original-value2");
+    List<LocalizedValueList> translations = List.of(LocalizedValueList.builder()
+        .language("de-De")
+        .value(List.of("value-value"))
+        .build());
+
+    FieldDisplayEntry fieldDisplayEntry = FieldDisplayEntry.builder()
+        .original(original)
+        .translations(translations)
+        .build();
+
+    assertNotNull(fieldDisplayEntry);
+    assertEquals(fieldDisplayEntry.original(), original);
+    assertEquals(fieldDisplayEntry.translations().size(), translations.size());
+    assertEquals(fieldDisplayEntry.translations().get(0), translations.get(0));
+  }
+
+  @Test
+  public void testConstructorWithNulls() {
+    FieldDisplayEntry fieldDisplayEntry = FieldDisplayEntry.builder()
+        .original(null)
+        .translations(null)
+        .build();
+
+    assertNotNull(fieldDisplayEntry);
+    assertNotNull(fieldDisplayEntry.original());
+    assertNotNull(fieldDisplayEntry.translations());
+    assertEquals(fieldDisplayEntry.original(), Collections.emptyList());
+    assertEquals(fieldDisplayEntry.translations(), Collections.emptyList());
+  }
+
+}