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

test: multiple choice fields

Browse Source
This commit is contained in:
Paul-Christian Volkmer
2025-07-06 15:41:29 +02:00
parent 87396e692e
commit 8db5abe9b7
17 changed files with 734 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -25,6 +25,7 @@ import dev.pcvolkmer.onco.datamapper.exceptions.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
@@ -66,11 +67,24 @@ public abstract class AbstractDataCatalogue implements DataCatalogue {
throw new DataAccessException("Multiple records found for id: " + id);
}
return ResultSet.from(result.get(0));
var resultSet = ResultSet.from(result.get(0));
if (resultSet.getRawData().containsKey("id")) {
var merkmale = getMerkmaleById(resultSet.getId());
if (merkmale.isEmpty()) {
return resultSet;
}
merkmale.forEach((key, value) ->
resultSet.getRawData().put(key, value)
);
}
return resultSet;
}
/**
* Returns related diseases
*
* @param procedureId The procedure id
* @return the diseases
*/
@@ -86,4 +100,32 @@ public abstract class AbstractDataCatalogue implements DataCatalogue {
.map(ResultSet::from)
.collect(Collectors.toList());
}
/**
* Get procedure "Merkmale" result by procedure id and form field name
*
* @param id The parents procedure id
* @return The sub procedures
*/
Map<String, List<String>> getMerkmaleById(int id) {
try {
var resultSet = this.jdbcTemplate.queryForList(
String.format(
"SELECT feldname, feldwert FROM %s_merkmale WHERE eintrag_id = ?",
getTableName()
),
id);
return resultSet.stream()
.collect(
Collectors.groupingBy(
m -> m.get("feldname").toString(),
Collectors.mapping(stringObjectMap -> stringObjectMap.get("feldwert").toString(), Collectors.toList())
)
);
} catch (org.springframework.dao.DataAccessException e) {
return Map.of();
}
}
}

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

@@ -72,31 +72,4 @@ public abstract class AbstractSubformDataCatalogue extends AbstractDataCatalogue
.collect(Collectors.toList());
}
/**
* Get procedure "Merkmale" result by procedure id and form field name
*
* @param id The parents procedure id
* @return The sub procedures
*/
Map<String, List<String>> getMerkmaleById(int id) {
try {
var resultSet = this.jdbcTemplate.queryForList(
String.format(
"SELECT feldname, feldwert FROM %s_merkmale WHERE eintrag_id = ?",
getTableName()
),
id);
return resultSet.stream()
.collect(
Collectors.groupingBy(
m -> m.get("feldname").toString(),
Collectors.mapping(stringObjectMap -> stringObjectMap.get("feldwert").toString(), Collectors.toList())
)
);
} catch (DataAccessException e) {
return Map.of();
}
}
}

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

@@ -20,6 +20,7 @@
package dev.pcvolkmer.onco.datamapper.datacatalogues;
import dev.pcvolkmer.onco.datamapper.ResultSet;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -28,14 +29,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class EcogCatalogueTest {
@@ -79,4 +81,47 @@ class EcogCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_ecog.*, prozedur.* FROM dk_dnpm_uf_ecog JOIN prozedur ON (prozedur.id = dk_dnpm_uf_ecog.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_ecog_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EinzelempfehlungCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class EinzelempfehlungCatalogueTest {
@@ -79,4 +80,47 @@ class EinzelempfehlungCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_einzelempfehlung.*, prozedur.* FROM dk_dnpm_uf_einzelempfehlung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_einzelempfehlung.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_einzelempfehlung_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class HistologieCatalogueTest {
@@ -79,4 +80,47 @@ class HistologieCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_histologie.*, prozedur.* FROM dk_dnpm_uf_histologie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_histologie.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_histologie_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -30,14 +30,15 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class KpaCatalogueTest {
@@ -75,4 +76,47 @@ class KpaCatalogueTest {
assertThat(ex).hasMessage("No record found for case: 16000123");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_kpa_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenetikCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class MolekulargenetikCatalogueTest {
@@ -64,4 +65,47 @@ class MolekulargenetikCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_molekulargenetik.*, prozedur.* FROM dk_molekulargenetik JOIN prozedur ON (prozedur.id = dk_molekulargenetik.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND prozedur.id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_molekulargenetik_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenuntersuchungCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class MolekulargenuntersuchungCatalogueTest {
@@ -79,4 +80,47 @@ class MolekulargenuntersuchungCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_molekulargenuntersuchung.*, prozedur.* FROM dk_molekulargenuntersuchung JOIN prozedur ON (prozedur.id = dk_molekulargenuntersuchung.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_molekulargenuntersuchung_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class ProzedurCatalogueTest {
@@ -79,4 +80,47 @@ class ProzedurCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_prozedur.*, prozedur.* FROM dk_dnpm_uf_prozedur JOIN prozedur ON (prozedur.id = dk_dnpm_uf_prozedur.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_prozedur_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/RebiopsieCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class RebiopsieCatalogueTest {
@@ -79,4 +80,47 @@ class RebiopsieCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_rebiopsie.*, prozedur.* FROM dk_dnpm_uf_rebiopsie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_rebiopsie.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_rebiopsie_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ReevaluationCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class ReevaluationCatalogueTest {
@@ -79,4 +80,47 @@ class ReevaluationCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_reevaluation.*, prozedur.* FROM dk_dnpm_uf_reevaluation JOIN prozedur ON (prozedur.id = dk_dnpm_uf_reevaluation.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_reevaluation_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TherapielinieCatalogueTest {
@@ -79,4 +80,47 @@ class TherapielinieCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_therapielinie.*, prozedur.* FROM dk_dnpm_therapielinie JOIN prozedur ON (prozedur.id = dk_dnpm_therapielinie.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_therapielinie_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

48
src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapieplanCatalogueTest.java
View File

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TherapieplanCatalogueTest {
@@ -79,4 +80,47 @@ class TherapieplanCatalogueTest {
.isEqualTo("SELECT prozedur.id AS procedure_id FROM dk_dnpm_therapieplan JOIN prozedur ON (prozedur.id = dk_dnpm_therapieplan.id) WHERE geloescht = 0 AND ref_dnpm_klinikanamnese = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_therapieplan_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TumorausbreitungCatalogueTest {
@@ -79,4 +80,47 @@ class TumorausbreitungCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_tumorausbreitung.*, prozedur.* FROM dk_dnpm_uf_tumorausbreitung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorausbreitung.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_tumorausbreitung_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class TumorgradingCatalogueTest {
@@ -79,4 +80,47 @@ class TumorgradingCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_tumorgrading.*, prozedur.* FROM dk_dnpm_uf_tumorgrading JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorgrading.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_tumorgrading_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class VerwandteCatalogueTest {
@@ -79,4 +80,47 @@ class VerwandteCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_verwandte.*, prozedur.* FROM dk_dnpm_uf_verwandte JOIN prozedur ON (prozedur.id = dk_dnpm_uf_verwandte.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_verwandte_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}

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

@@ -28,14 +28,15 @@ import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.jdbc.core.JdbcTemplate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class VorbefundeCatalogueTest {
@@ -79,4 +80,47 @@ class VorbefundeCatalogueTest {
.isEqualTo("SELECT patient.patienten_id, dk_dnpm_uf_vorbefunde.*, prozedur.* FROM dk_dnpm_uf_vorbefunde JOIN prozedur ON (prozedur.id = dk_dnpm_uf_vorbefunde.id) JOIN patient ON (patient.id = prozedur.patient_id) WHERE geloescht = 0 AND hauptprozedur_id = ?");
}
@Test
void shouldUseCorrectMerkmalQuery(@Mock Map<String, Object> resultSet) {
when(resultSet.get(anyString()))
.thenReturn(Map.of("feldname", "name", "feldwert", "wert"));
doAnswer(invocationOnMock -> List.of(resultSet))
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
this.catalogue.getMerkmaleById(1);
var captor = ArgumentCaptor.forClass(String.class);
verify(this.jdbcTemplate).queryForList(captor.capture(), anyInt());
assertThat(captor.getValue())
.isEqualTo("SELECT feldname, feldwert FROM dk_dnpm_uf_vorbefunde_merkmale WHERE eintrag_id = ?");
}
@Test
void shouldUseMerkmalList() {
doAnswer(invocationOnMock -> {
var sql = invocationOnMock.getArgument(0, String.class);
ArrayList<Map<String, Object>> result = new ArrayList<>();
if (sql.startsWith("SELECT feldname")) {
result.add(Map.of("feldname", "name", "feldwert", "wert1"));
result.add(Map.of("feldname", "name", "feldwert", "wert2"));
} else {
var map = new HashMap<String, Object>();
map.put("id", 1);
map.put("name", "x");
result.add(map);
}
return result;
})
.when(jdbcTemplate)
.queryForList(anyString(), anyInt());
var result = this.catalogue.getById(1);
assertThat(result.getInteger("id")).isEqualTo(1);
assertThat(result.getMerkmalList("name")).isEqualTo(List.of("wert1", "wert2"));
}
}