pcvolkmer/mv64e-onkostar-data
1
0
Fork 0
mirror of https://github.com/pcvolkmer/mv64e-onkostar-data.git synced 2025-07-02 02:22:54 +00:00
Code Activity

refactor: use Map instead of ResultSet

Browse Source
This commit is contained in:
Paul-Christian Volkmer
2025-06-20 22:48:20 +02:00
parent e8d4b36d13
commit dd67d86d31
21 changed files with 195 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/main/java/dev/pcvolkmer/onco/datamapper/KpaDiagnosisDataMapper.java
View File

@ -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"))
.code(
Coding.builder()
.code(data.getString("icd10"))
.build()
);
} catch (SQLException e) {
throw new DataAccessException(e.getMessage());
}
builder
.id(asString(data.get("id")))
.code(
Coding.builder()
.code(asString(data.get("icd10")))
.build()
);
return builder.build();
}

39
src/main/java/dev/pcvolkmer/onco/datamapper/KpaPatientDataMapper.java
View File

@ -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.sql.SQLException;
import java.util.Map;
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"))
.gender(getGenderCoding(kpaData))
.birthDate(mapDate(kpaData.getDate("geburtsdatum")))
.dateOfDeath(mapDate(kpaData.getDate("sterbedatum")))
.healthInsurance(getHealthInsurance(kpaData))
;
} catch (SQLException e) {
throw new DataAccessException(e.getMessage());
}
builder
.id(asString(kpaData.get("patient_id")))
.gender(getGenderCoding(kpaData))
.birthDate(mapDate(asDate(kpaData.get("geburtsdatum"))))
.dateOfDeath(mapDate(asDate(kpaData.get("todesdatum"))))
.healthInsurance(getHealthInsurance(kpaData))
;
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();

34
src/main/java/dev/pcvolkmer/onco/datamapper/PatientDataMapper.java
View File

@ -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.sql.SQLException;
import java.util.Date;
import java.util.Map;
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"))
.gender(getGenderCoding(patientData))
.birthDate(mapDate(patientData.getDate("geburtsdatum")))
.dateOfDeath(mapDate(patientData.getDate("sterbedatum")))
.address(Address.builder().municipalityCode(getMunicipalityCode(patientData)).build())
;
} catch (SQLException e) {
throw new DataAccessException(e.getMessage());
}
builder
.id(asString(patientData.get("id")))
.gender(getGenderCoding(patientData))
.birthDate(mapDate(asDate(patientData.get("geburtsdatum"))))
.dateOfDeath(mapDate(asDate(patientData.get("sterbedatum"))))
.address(Address.builder().municipalityCode(getMunicipalityCode(patientData)).build())
;
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 {
var gkz = data.getString("GKZ");
private String getMunicipalityCode(Map<String, Object> data) {
var gkz = asString(data.get("GKZ"));
if (gkz == null || gkz.trim().length() != 8) {
throw new DataAccessException("Municipality code not found");
}

31
src/main/java/dev/pcvolkmer/onco/datamapper/TypeMapper.java Normal file
View File

@ -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");
}
}

7
src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java
View File

@ -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) {
var result = this.jdbcTemplate.query(
public Map<String, Object> getById(int id) {
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()) {

7
src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java
View File

@ -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) {
return this.jdbcTemplate.query(
public List<Map<String, Object>> getAllByMainId(int id) {
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);
}

4
src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/DataCatalogue.java
View File

@ -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);
}

11
src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/PatientCatalogue.java
View File

@ -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) {
var result = this.jdbcTemplate.query(
@Override
public Map<String, Object> getById(int id) {
var result = this.jdbcTemplate.queryForList(
"SELECT * FROM patient WHERE id = ?",
(resultSet, i) -> resultSet,
id);
if (result.isEmpty()) {

12
src/test/java/dev/pcvolkmer/onco/datamapper/KpaDiagnosisDataMapperTest.java
View File

@ -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);

30
src/test/java/dev/pcvolkmer/onco/datamapper/KpaPatientDataMapperTest.java
View File

@ -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);

1
src/test/java/dev/pcvolkmer/onco/datamapper/MtbDataMapperTest.java
View File

@ -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;

27
src/test/java/dev/pcvolkmer/onco/datamapper/PatientDataMapperTest.java
View File

@ -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);

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java
View File

@ -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 = ?");

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java
View File

@ -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 = ?");

14
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java
View File

@ -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 = ?");
}
}

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java
View File

@ -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 = ?");

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java
View File

@ -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 = ?");

15
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java
View File

@ -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 = ?");

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java
View File

@ -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 = ?");

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java
View File

@ -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 = ?");

20
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java
View File

@ -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 = ?");