feat: add subform catalogues for KPA

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

@@ -30,7 +30,7 @@ public abstract class AbstractDataCatalogue implements DataCatalogue {
     @Override
     public ResultSet getById(int id) {
         var result = this.jdbcTemplate.query(
-                String.format("SELECT * FROM %s JOIN prozedur ON (prozedur.id = dk_dnpm_kpa.id) WHERE id = ?", getTableName()),
+                String.format("SELECT * FROM %s JOIN prozedur ON (prozedur.id = %s.id) WHERE id = ?", getTableName(), getTableName()),
                 (resultSet, i) -> resultSet,
                 id);
 

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

@@ -28,7 +28,7 @@ public abstract class AbstractSubformDataCatalogue extends AbstractDataCatalogue
      */
     public List<ResultSet> getAllByMainId(int id) {
         var result = this.jdbcTemplate.query(
-                String.format("SELECT * FROM %s JOIN prozedur ON (prozedur.id = dk_dnpm_kpa.id) WHERE hauptprozedur = ?", getTableName()),
+                String.format("SELECT * FROM %s JOIN prozedur ON (prozedur.id = %s.id) WHERE hauptprozedur = ?", getTableName(), getTableName()),
                 (resultSet, i) -> resultSet,
                 id);
 

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_ecog'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class EcogCatalogue extends AbstractSubformDataCatalogue {
+
+    private EcogCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_ecog";
+    }
+
+    public static EcogCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new EcogCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_histologie'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class HistologieCatalogue extends AbstractSubformDataCatalogue {
+
+    private HistologieCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_histologie";
+    }
+
+    public static HistologieCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new HistologieCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_prozedur'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class ProzedurCatalogue extends AbstractSubformDataCatalogue {
+
+    private ProzedurCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_prozedur";
+    }
+
+    public static ProzedurCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new ProzedurCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_therapielinie'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class TherapielinieCatalogue extends AbstractSubformDataCatalogue {
+
+    private TherapielinieCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_therapielinie";
+    }
+
+    public static TherapielinieCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new TherapielinieCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_tumorausbreitung'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class TumorausbreitungCatalogue extends AbstractSubformDataCatalogue {
+
+    private TumorausbreitungCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_tumorausbreitung";
+    }
+
+    public static TumorausbreitungCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new TumorausbreitungCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_tumorgrading'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class TumorgradingCatalogue extends AbstractSubformDataCatalogue {
+
+    private TumorgradingCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_tumorgrading";
+    }
+
+    public static TumorgradingCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new TumorgradingCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_verwandte'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class VerwandteCatalogue extends AbstractSubformDataCatalogue {
+
+    private VerwandteCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_verwandte";
+    }
+
+    public static VerwandteCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new VerwandteCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,26 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.springframework.jdbc.core.JdbcTemplate;
+
+/**
+ * Load raw result sets from database table 'dk_dnpm_uf_vorbefunde'
+ *
+ * @author Paul-Christian Volkmer
+ * @since 0.1
+ */
+public class VorbefundeCatalogue extends AbstractSubformDataCatalogue {
+
+    private VorbefundeCatalogue(JdbcTemplate jdbcTemplate) {
+        super(jdbcTemplate);
+    }
+
+    @Override
+    protected String getTableName() {
+        return "dk_dnpm_uf_vorbefunde";
+    }
+
+    public static VorbefundeCatalogue create(JdbcTemplate jdbcTemplate) {
+        return new VorbefundeCatalogue(jdbcTemplate);
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class EcogCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    EcogCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = EcogCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_ecog JOIN prozedur ON (prozedur.id = dk_dnpm_uf_ecog.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class HistologieCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    HistologieCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = HistologieCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_histologie JOIN prozedur ON (prozedur.id = dk_dnpm_uf_histologie.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class ProzedurCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    ProzedurCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = ProzedurCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_prozedur JOIN prozedur ON (prozedur.id = dk_dnpm_uf_prozedur.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TherapielinieCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    TherapielinieCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = TherapielinieCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_therapielinie JOIN prozedur ON (prozedur.id = dk_dnpm_therapielinie.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TumorausbreitungCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    TumorausbreitungCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = TumorausbreitungCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorausbreitung JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorausbreitung.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TumorgradingCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    TumorgradingCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = TumorgradingCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_tumorgrading JOIN prozedur ON (prozedur.id = dk_dnpm_uf_tumorgrading.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class VerwandteCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    VerwandteCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = VerwandteCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_verwandte JOIN prozedur ON (prozedur.id = dk_dnpm_uf_verwandte.id) WHERE id = ?");
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package dev.pcvolkmer.onco.datamapper.datacatalogues;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+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 static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class VorbefundeCatalogueTest {
+
+    JdbcTemplate jdbcTemplate;
+    VorbefundeCatalogue catalogue;
+
+    @BeforeEach
+    void setUp(@Mock JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.catalogue = VorbefundeCatalogue.create(jdbcTemplate);
+    }
+
+    @Test
+    void shouldUseCorrectQuery(@Mock ResultSet resultSet) {
+        doAnswer(invocationOnMock -> List.of(resultSet))
+                .when(jdbcTemplate)
+                .query(anyString(), any(RowMapper.class), anyInt());
+
+        this.catalogue.getById(1);
+
+        var captor = ArgumentCaptor.forClass(String.class);
+        verify(this.jdbcTemplate).query(captor.capture(), any(RowMapper.class), anyInt());
+
+        assertThat(captor.getValue())
+                .isEqualTo("SELECT * FROM dk_dnpm_uf_vorbefunde JOIN prozedur ON (prozedur.id = dk_dnpm_uf_vorbefunde.id) WHERE id = ?");
+    }
+
+}