refactor: use Map instead of ResultSet

src/test/java/dev/pcvolkmer/onco/datamapper/KpaDiagnosisDataMapperTest.java

@@ -7,16 +7,14 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
 import javax.sql.DataSource;
-import java.sql.ResultSet;
-import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 
 @ExtendWith(MockitoExtension.class)
@@ -38,15 +36,15 @@ class KpaDiagnosisDataMapperTest {
     }
 
     @Test
-    void shouldCreateDiagnosis(@Mock ResultSet resultSet) throws SQLException {
+    void shouldCreateDiagnosis(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> {
             var columnName = invocationOnMock.getArgument(0, String.class);
             return testData().get(columnName);
-        }).when(resultSet).getString(anyString());
+        }).when(resultSet).get(anyString());
 
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         var actual = this.dataMapper.getById(1);
         assertThat(actual).isInstanceOf(MtbDiagnosis.class);

src/test/java/dev/pcvolkmer/onco/datamapper/KpaPatientDataMapperTest.java

@@ -7,18 +7,16 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
 import javax.sql.DataSource;
-import java.sql.ResultSet;
-import java.sql.SQLException;
 import java.time.Instant;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 
 @ExtendWith(MockitoExtension.class)
@@ -40,28 +38,23 @@ class KpaPatientDataMapperTest {
     }
 
     @Test
-    void shouldCreatePatientAlive(@Mock ResultSet resultSet) throws SQLException {
+    void shouldCreatePatientAlive(@Mock Map<String, Object> resultSet) {
         var testData = Map.of(
                 "patient_id", "1",
                 "geschlecht", "m",
                 "geburtsdatum", new java.sql.Date(Date.from(Instant.parse("2000-01-01T12:00:00Z")).getTime()),
-                "sterbedatum", new java.sql.Date(Date.from(Instant.parse("2024-06-19T12:00:00Z")).getTime()),
+                "todesdatum", new java.sql.Date(Date.from(Instant.parse("2024-06-19T12:00:00Z")).getTime()),
                 "artderkrankenkasse", "GKV"
         );
 
         doAnswer(invocationOnMock -> {
             var columnName = invocationOnMock.getArgument(0, String.class);
             return testData.get(columnName);
-        }).when(resultSet).getString(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(anyString());
+        }).when(resultSet).get(anyString());
 
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         var actual = this.dataMapper.getById(1);
         assertThat(actual).isInstanceOf(Patient.class);
@@ -75,7 +68,7 @@ class KpaPatientDataMapperTest {
     }
 
     @Test
-    void shouldCreatePatientDead(@Mock ResultSet resultSet) throws SQLException {
+    void shouldCreatePatientDead(@Mock Map<String, Object> resultSet) {
         var testData = Map.of(
                 "patient_id", "1",
                 "geschlecht", "w",
@@ -86,16 +79,11 @@ class KpaPatientDataMapperTest {
         doAnswer(invocationOnMock -> {
             var columnName = invocationOnMock.getArgument(0, String.class);
             return testData.get(columnName);
-        }).when(resultSet).getString(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(anyString());
+        }).when(resultSet).get(anyString());
 
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         var actual = this.dataMapper.getById(1);
         assertThat(actual).isInstanceOf(Patient.class);

src/test/java/dev/pcvolkmer/onco/datamapper/MtbDataMapperTest.java

@@ -11,7 +11,6 @@ import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.RowMapper;
 
 import javax.sql.DataSource;
-
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;

src/test/java/dev/pcvolkmer/onco/datamapper/PatientDataMapperTest.java

@@ -9,10 +9,8 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
 import javax.sql.DataSource;
-import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.Instant;
 import java.util.Date;
@@ -20,7 +18,8 @@ import java.util.List;
 import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 
 @ExtendWith(MockitoExtension.class)
@@ -42,7 +41,7 @@ class PatientDataMapperTest {
     }
 
     @Test
-    void shouldCreatePatientAlive(@Mock ResultSet resultSet) throws SQLException {
+    void shouldCreatePatientAlive(@Mock Map<String, Object> resultSet) throws SQLException {
         var testData = Map.of(
                 "id", "1",
                 "geschlecht", "M",
@@ -54,16 +53,11 @@ class PatientDataMapperTest {
         doAnswer(invocationOnMock -> {
             var columnName = invocationOnMock.getArgument(0, String.class);
             return testData.get(columnName);
-        }).when(resultSet).getString(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(anyString());
+        }).when(resultSet).get(anyString());
 
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         var actual = this.dataMapper.getById(1);
         assertThat(actual).isInstanceOf(Patient.class);
@@ -75,7 +69,7 @@ class PatientDataMapperTest {
     }
 
     @Test
-    void shouldCreatePatientDead(@Mock ResultSet resultSet) throws SQLException {
+    void shouldCreatePatientDead(@Mock Map<String, Object> resultSet) throws SQLException {
         var testData = Map.of(
                 "id", "1",
                 "geschlecht", "M",
@@ -86,16 +80,11 @@ class PatientDataMapperTest {
         doAnswer(invocationOnMock -> {
             var columnName = invocationOnMock.getArgument(0, String.class);
             return testData.get(columnName);
-        }).when(resultSet).getString(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(anyString());
+        }).when(resultSet).get(anyString());
 
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         var actual = this.dataMapper.getById(1);
         assertThat(actual).isInstanceOf(Patient.class);

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class EcogCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_ecog JOIN prozedur ON (prozedur.id = dk_dnpm_uf_ecog.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_ecog JOIN prozedur ON (prozedur.id = dk_dnpm_uf_ecog.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_ecog JOIN prozedur ON (prozedur.id = dk_dnpm_uf_ecog.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class HistologieCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_histologie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_histologie.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_histologie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_histologie.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_histologie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_histologie.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,18 +30,18 @@ class KpaCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_kpa JOIN prozedur ON (prozedur.id = dk_dnpm_kpa.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_kpa JOIN prozedur ON (prozedur.id = dk_dnpm_kpa.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
 }

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class ProzedurCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_prozedur JOIN prozedur ON (prozedur.id = dk_dnpm_uf_prozedur.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_prozedur JOIN prozedur ON (prozedur.id = dk_dnpm_uf_prozedur.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_prozedur JOIN prozedur ON (prozedur.id = dk_dnpm_uf_prozedur.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class TherapielinieCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_therapielinie JOIN prozedur ON (prozedur.id = dk_dnpm_therapielinie.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_therapielinie JOIN prozedur ON (prozedur.id = dk_dnpm_therapielinie.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_therapielinie JOIN prozedur ON (prozedur.id = dk_dnpm_therapielinie.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java

@@ -11,6 +11,7 @@ import org.springframework.jdbc.core.RowMapper;
 
 import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.*;
@@ -30,30 +31,30 @@ class TumorausbreitungCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorausbreitung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorausbreitung.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorausbreitung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorausbreitung.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorausbreitung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorausbreitung.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class TumorgradingCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorgrading JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorgrading.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorgrading JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorgrading.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorgrading JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorgrading.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class VerwandteCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_verwandte JOIN prozedur ON (prozedur.id = dk_dnpm_uf_verwandte.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_verwandte JOIN prozedur ON (prozedur.id = dk_dnpm_uf_verwandte.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_verwandte JOIN prozedur ON (prozedur.id = dk_dnpm_uf_verwandte.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");

src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java

@@ -7,13 +7,13 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.jdbc.core.RowMapper;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.verify;
 
@@ -30,30 +30,30 @@ class VorbefundeCatalogueTest {
     }
 
     @Test
-    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getById(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
-                .isEqualTo("SELECT * FROM dk_dnpm_uf_vorbefunde JOIN prozedur ON (prozedur.id = dk_dnpm_uf_vorbefunde.id) WHERE geloescht = 0 AND id = ?");
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_vorbefunde JOIN prozedur ON (prozedur.id = dk_dnpm_uf_vorbefunde.id) WHERE geloescht = 0 AND prozedur.id = ?");
     }
 
     @Test
-    void shouldUseCorrectSubformQuery(@Mock ResultSet resultSet) {
+    void shouldUseCorrectSubformQuery(@Mock Map<String, Object> resultSet) {
         doAnswer(invocationOnMock -> List.of(resultSet))
                 .when(jdbcTemplate)
-                .query(anyString(), any(RowMapper.class), anyInt());
+                .queryForList(anyString(), anyInt());
 
         this.catalogue.getAllByMainId(1);
 
         var captor = ArgumentCaptor.forClass(String.class);
-        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+        verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
 
         assertThat(captor.getValue())
                 .isEqualTo("SELECT * FROM dk_dnpm_uf_vorbefunde JOIN prozedur ON (prozedur.id = dk_dnpm_uf_vorbefunde.id) WHERE geloescht = 0 AND hauptprozedur_id = ?");