diff --git a/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java b/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java index 9628296..a487c97 100644 --- a/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java +++ b/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractDataCatalogue.java @@ -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> 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(); + } + } + } diff --git a/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java b/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java index ac303d9..7f2a598 100644 --- a/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java +++ b/src/main/java/dev/pcvolkmer/onco/datamapper/datacatalogues/AbstractSubformDataCatalogue.java @@ -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> 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(); - } - } - } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java index 20d4308..d4bb950 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EcogCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EinzelempfehlungCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EinzelempfehlungCatalogueTest.java index 28c13ff..878b08f 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EinzelempfehlungCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/EinzelempfehlungCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java index 51f6631..85e8ef3 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/HistologieCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java index 13820d1..6ecc474 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/KpaCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenetikCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenetikCatalogueTest.java index cc67e90..642281c 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenetikCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenetikCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenuntersuchungCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenuntersuchungCatalogueTest.java index a0f96e7..e58d80c 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenuntersuchungCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/MolekulargenuntersuchungCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java index 8750467..4a2c815 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ProzedurCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/RebiopsieCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/RebiopsieCatalogueTest.java index 94e04be..e9561a2 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/RebiopsieCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/RebiopsieCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ReevaluationCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ReevaluationCatalogueTest.java index 86f6f6b..c796512 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ReevaluationCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/ReevaluationCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java index 5338cda..415ffe9 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapielinieCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapieplanCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapieplanCatalogueTest.java index 3191102..3590e5e 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapieplanCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TherapieplanCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java index 249c11f..7365b57 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorausbreitungCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java index 4bdb1d6..8692c75 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/TumorgradingCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java index b18c60d..5e1bc03 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VerwandteCatalogueTest.java @@ -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 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> 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(); + 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")); + } + } diff --git a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java index 019c845..85307f1 100644 --- a/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java +++ b/src/test/java/dev/pcvolkmer/onco/datamapper/datacatalogues/VorbefundeCatalogueTest.java @@ -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 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> 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(); + 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")); + } + }