feat: add subform catalogues for KPA

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