refactor: use Map instead of ResultSet

src/main/java/dev/pcvolkmer/onco/datamapper/KpaDiagnosisDataMapper.java

@@ -3,10 +3,9 @@ package dev.pcvolkmer.onco.datamapper;
 import dev.pcvolkmer.mv64e.mtb.Coding;
 import dev.pcvolkmer.mv64e.mtb.MtbDiagnosis;
 import dev.pcvolkmer.onco.datamapper.datacatalogues.KpaCatalogue;
-import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.SQLException;
+import static dev.pcvolkmer.onco.datamapper.TypeMapper.asString;
 
 /**
  * Mapper class to load and map diagnosis data from database table 'dk_dnpm_kpa'
@@ -44,17 +43,13 @@ public class KpaDiagnosisDataMapper implements DataMapper<MtbDiagnosis> {
         var data = kpa.getById(id);
 
         var builder =  MtbDiagnosis.builder();
-        try {
         builder
-                    .id(data.getString("id"))
+                .id(asString(data.get("id")))
                 .code(
                         Coding.builder()
-                                    .code(data.getString("icd10"))
+                                .code(asString(data.get("icd10")))
                                 .build()
                 );
-        } catch (SQLException e) {
-            throw new DataAccessException(e.getMessage());
-        }
         return builder.build();
     }
 

src/main/java/dev/pcvolkmer/onco/datamapper/KpaPatientDataMapper.java

@@ -2,11 +2,12 @@ package dev.pcvolkmer.onco.datamapper;
 
 import dev.pcvolkmer.mv64e.mtb.*;
 import dev.pcvolkmer.onco.datamapper.datacatalogues.KpaCatalogue;
-import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.ResultSet;
+import java.util.Map;
-import java.sql.SQLException;
+
+import static dev.pcvolkmer.onco.datamapper.TypeMapper.asDate;
+import static dev.pcvolkmer.onco.datamapper.TypeMapper.asString;
 
 /**
  * Mapper class to load and map patient data from database table 'dk_dnpm_kpa'
@@ -44,24 +45,19 @@ public class KpaPatientDataMapper implements DataMapper<Patient> {
         var kpaData = kpaCatalogue.getById(id);
 
         var builder = Patient.builder();
-        try {
         builder
-                    .id(kpaData.getString("patient_id"))
+                .id(asString(kpaData.get("patient_id")))
                 .gender(getGenderCoding(kpaData))
-                    .birthDate(mapDate(kpaData.getDate("geburtsdatum")))
+                .birthDate(mapDate(asDate(kpaData.get("geburtsdatum"))))
-                    .dateOfDeath(mapDate(kpaData.getDate("sterbedatum")))
+                .dateOfDeath(mapDate(asDate(kpaData.get("todesdatum"))))
                 .healthInsurance(getHealthInsurance(kpaData))
         ;
-
-        } catch (SQLException e) {
-            throw new DataAccessException(e.getMessage());
-        }
         return builder.build();
     }
 
-    private GenderCoding getGenderCoding(ResultSet data) throws SQLException {
+    private GenderCoding getGenderCoding(Map<String, Object> data) {
         var genderCodingBuilder = GenderCoding.builder();
-        String geschlecht = data.getString("geschlecht");
+        String geschlecht = asString(data.get("geschlecht"));
         switch (geschlecht) {
             case "m":
                 genderCodingBuilder.code(GenderCodingCode.MALE);
@@ -79,9 +75,14 @@ public class KpaPatientDataMapper implements DataMapper<Patient> {
         return genderCodingBuilder.build();
     }
 
-    private HealthInsurance getHealthInsurance(ResultSet data) throws SQLException {
+    private HealthInsurance getHealthInsurance(Map<String, Object> data) {
         var healthInsuranceCodingBuilder = HealthInsuranceCoding.builder();
-        String healthInsuranceType = data.getString("artderkrankenkasse");
+        String healthInsuranceType = asString(data.get("artderkrankenkasse"));
+        if (healthInsuranceType == null) {
+            healthInsuranceCodingBuilder.code(HealthInsuranceCodingCode.UNK).build();
+            return HealthInsurance.builder().type(healthInsuranceCodingBuilder.build()).build();
+        }
+
         switch (healthInsuranceType) {
             case "GKV":
                 healthInsuranceCodingBuilder.code(HealthInsuranceCodingCode.GKV).build();

src/main/java/dev/pcvolkmer/onco/datamapper/PatientDataMapper.java

@@ -8,9 +8,10 @@ import dev.pcvolkmer.onco.datamapper.datacatalogues.PatientCatalogue;
 import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.ResultSet;
+import java.util.Map;
-import java.sql.SQLException;
+
-import java.util.Date;
+import static dev.pcvolkmer.onco.datamapper.TypeMapper.asDate;
+import static dev.pcvolkmer.onco.datamapper.TypeMapper.asString;
 
 /**
  * Mapper class to load and map diagnosis data from database table 'dk_dnpm_kpa'
@@ -48,24 +49,19 @@ public class PatientDataMapper implements DataMapper<Patient> {
         var patientData = patientCatalogue.getById(id);
 
         var builder = Patient.builder();
-        try {
         builder
-                    .id(patientData.getString("id"))
+                .id(asString(patientData.get("id")))
                 .gender(getGenderCoding(patientData))
-                    .birthDate(mapDate(patientData.getDate("geburtsdatum")))
+                .birthDate(mapDate(asDate(patientData.get("geburtsdatum"))))
-                    .dateOfDeath(mapDate(patientData.getDate("sterbedatum")))
+                .dateOfDeath(mapDate(asDate(patientData.get("sterbedatum"))))
                 .address(Address.builder().municipalityCode(getMunicipalityCode(patientData)).build())
         ;
-
-        } catch (SQLException e) {
-            throw new DataAccessException(e.getMessage());
-        }
         return builder.build();
     }
 
-    private GenderCoding getGenderCoding(ResultSet data) throws SQLException {
+    private GenderCoding getGenderCoding(Map<String, Object> data) {
         var genderCodingBuilder = GenderCoding.builder();
-        String geschlecht = data.getString("geschlecht");
+        String geschlecht = asString(data.get("geschlecht"));
         switch (geschlecht) {
             case "M":
                 genderCodingBuilder.code(GenderCodingCode.MALE);
@@ -82,8 +78,8 @@ public class PatientDataMapper implements DataMapper<Patient> {
         return genderCodingBuilder.build();
     }
 
-    private String getMunicipalityCode(ResultSet data) throws SQLException {
+    private String getMunicipalityCode(Map<String, Object> data) {
-        var gkz = data.getString("GKZ");
+        var gkz = asString(data.get("GKZ"));
         if (gkz == null || gkz.trim().length() != 8) {
             throw new DataAccessException("Municipality code not found");
         }

src/main/java/dev/pcvolkmer/onco/datamapper/TypeMapper.java

@@ -0,0 +1,31 @@
+package dev.pcvolkmer.onco.datamapper;
+
+import java.sql.Date;
+
+public class TypeMapper {
+
+    public static String asString(Object raw) {
+        if (raw == null) {
+            return null;
+        }
+        if (raw instanceof String) {
+            return (String) raw;
+        } else if (raw instanceof Integer) {
+            return ((Integer) raw).toString();
+        }
+
+        throw new IllegalArgumentException("Cannot convert " + raw.getClass() + " to String");
+    }
+
+    public static Date asDate(Object raw) {
+        if (raw == null) {
+            return null;
+        }
+        if (raw instanceof Date) {
+            return (Date) raw;
+        }
+
+        throw new IllegalArgumentException("Cannot convert " + raw.getClass() + " to Date");
+    }
+
+}

src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java

@@ -3,7 +3,7 @@ package dev.pcvolkmer.onco.datamapper.datacatalogues;
 import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.ResultSet;
+import java.util.Map;
 
 /**
  * Common implementations for all data catalogues
@@ -28,14 +28,13 @@ public abstract class AbstractDataCatalogue implements DataCatalogue {
      * @return The procedure id
      */
     @Override
-    public ResultSet getById(int id) {
+    public Map<String, Object> getById(int id) {
-        var result = this.jdbcTemplate.query(
+        var result = this.jdbcTemplate.queryForList(
                 String.format(
                         "SELECT * FROM %s JOIN prozedur ON (prozedur.id = %s.id) WHERE geloescht = 0 AND prozedur.id = ?",
                         getTableName(),
                         getTableName()
                 ),
-                (resultSet, i) -> resultSet,
                 id);
 
         if (result.isEmpty()) {

src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java

@@ -2,8 +2,8 @@ package dev.pcvolkmer.onco.datamapper.datacatalogues;
 
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.ResultSet;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Common implementations for all data catalogues used in subforms
@@ -25,14 +25,13 @@ public abstract class AbstractSubformDataCatalogue extends AbstractDataCatalogue
      * @param id The procedure id
      * @return The procedure id
      */
-    public List<ResultSet> getAllByMainId(int id) {
+    public List<Map<String, Object>> getAllByMainId(int id) {
-        return this.jdbcTemplate.query(
+        return this.jdbcTemplate.queryForList(
                 String.format(
                         "SELECT * FROM %s JOIN prozedur ON (prozedur.id = %s.id) WHERE geloescht = 0 AND hauptprozedur_id = ?",
                         getTableName(),
                         getTableName()
                 ),
-                (resultSet, i) -> resultSet,
                 id);
     }
 

src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/DataCatalogue.java

@@ -1,6 +1,6 @@
 package dev.pcvolkmer.onco.datamapper.datacatalogues;
 
-import java.sql.ResultSet;
+import java.util.Map;
 
 /**
  * Common interface for all data catalogues
@@ -15,6 +15,6 @@ public interface DataCatalogue {
      * @param id The database id (primary key)
      * @return The result set
      */
-    ResultSet getById(int id);
+    Map<String, Object> getById(int id);
 
 }

src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/PatientCatalogue.java

@@ -3,7 +3,7 @@ package dev.pcvolkmer.onco.datamapper.datacatalogues;
 import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
 import org.springframework.jdbc.core.JdbcTemplate;
 
-import java.sql.ResultSet;
+import java.util.Map;
 
 /**
  * Load raw result sets from database table 'patient'
@@ -11,7 +11,7 @@ import java.sql.ResultSet;
  * @author Paul-Christian Volkmer
  * @since 0.1
  */
-public class PatientCatalogue {
+public class PatientCatalogue implements DataCatalogue {
 
     private final JdbcTemplate jdbcTemplate;
 
@@ -28,10 +28,11 @@ public class PatientCatalogue {
      * @param id The procedure id
      * @return The procedure id
      */
-    public ResultSet getById(int id) {
+    @Override
-        var result = this.jdbcTemplate.query(
+    public Map<String, Object> getById(int id) {
+
+        var result = this.jdbcTemplate.queryForList(
                 "SELECT * FROM patient WHERE id = ?",
-                (resultSet, i) -> resultSet,
                 id);
 
         if (result.isEmpty()) {

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());
+        }).when(resultSet).get(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(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());
+        }).when(resultSet).get(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(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());
+        }).when(resultSet).get(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(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());
+        }).when(resultSet).get(anyString());
-
-        doAnswer(invocationOnMock -> {
-            var columnName = invocationOnMock.getArgument(0, String.class);
-            return testData.get(columnName);
-        }).when(resultSet).getDate(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 = ?");