From fb91356b7777dfa5b6088bcc3a48b43924c1c0fd Mon Sep 17 00:00:00 2001 From: Paul-Christian Volkmer Date: Thu, 3 Sep 2026 14:35:10 +0200 Subject: build: apply Spotless plugin (#293) --- src/test/java/de/itc/utils/DateFormats.java | 11 +- src/test/java/de/itc/utils/MapUtilities.java | 18 +- .../java/dev/dnpm/oshelper/ConsentManagerTest.java | 68 ++-- .../java/dev/dnpm/oshelper/DNPMHelperTest.java | 386 +++++++++++---------- .../dev/dnpm/oshelper/MerkmalskatalogTest.java | 78 ++--- .../dnpm/oshelper/analyzer/AnalyzerUtilsTest.java | 231 ++++++------ .../analyzer/EinzelempfehlungAnalyzerTest.java | 174 +++++----- .../oshelper/analyzer/FollowUpAnalyzerTest.java | 95 +++-- .../analyzer/TherapieMitEcogAnalyzerTest.java | 302 ++++++++-------- .../analyzer/TherapieplanAnalyzerTest.java | 38 +- .../dnpm/oshelper/atc/AgentCodeServiceTest.java | 90 +++-- .../java/dev/dnpm/oshelper/atc/AtcCodeTest.java | 37 +- .../dnpm/oshelper/atc/CsvAgentCodeServiceTest.java | 19 +- .../oshelper/config/PluginConfigurationTest.java | 48 ++- .../java/dev/dnpm/oshelper/dto/VariantTest.java | 187 +++++----- ...DelegatingDataBasedPermissionEvaluatorTest.java | 225 ++++++------ .../security/FormBasedPermissionEvaluatorTest.java | 219 +++++++----- .../security/FormBasedSecurityAspectsTest.java | 212 +++++------ .../PersonPoolBasedPermissionEvaluatorTest.java | 323 +++++++++-------- .../PersonPoolBasedSecurityAspectsTest.java | 279 +++++++-------- .../oshelper/services/SettingsServiceTest.java | 79 +++-- .../dev/dnpm/oshelper/services/StudieTest.java | 60 +--- .../consent/ConsentManagerServiceFactoryTest.java | 56 ++- .../consent/MrConsentManagerServiceTest.java | 64 ++-- .../consent/UkwConsentManagerServiceTest.java | 185 +++++----- .../OsMolekluargenetikFormServiceTest.java | 63 ++-- .../mtb/MrMtbAnmeldungToProtocolMapperTest.java | 223 ++++++------ .../mtb/OsTumorkonferenzToProtocolMapperTest.java | 50 ++- ...orkonferenzVarianteUkwToProtocolMapperTest.java | 50 ++- .../DefaultStrahlentherapieServiceTest.java | 186 +++++----- .../DefaultSystemtherapieServiceTest.java | 240 +++++++------ .../ProzedurToProzedurwerteMapperTest.java | 98 +++--- .../DefaultTherapieplanServiceTest.java | 316 +++++++++-------- .../TherapieplanServiceFactoryTest.java | 42 +-- 34 files changed, 2416 insertions(+), 2336 deletions(-) (limited to 'src/test/java') diff --git a/src/test/java/de/itc/utils/DateFormats.java b/src/test/java/de/itc/utils/DateFormats.java index 1723f4a..8ee58e0 100644 --- a/src/test/java/de/itc/utils/DateFormats.java +++ b/src/test/java/de/itc/utils/DateFormats.java @@ -22,14 +22,13 @@ package de.itc.utils; import java.util.Date; /** - * Diese Klasse dient nur Testzwecken, da die Klasse und enthaltene(n) Methode(n) von der Onkostar-API - * benötigt und verwendet werden, nicht jedoch in der Onkostar-API-JAR enthalten sind. + * Diese Klasse dient nur Testzwecken, da die Klasse und enthaltene(n) Methode(n) von der + * Onkostar-API benötigt und verwendet werden, nicht jedoch in der Onkostar-API-JAR enthalten sind. * Das tatsächliche Verhalten innerhalb von Onkostar wird abweichen. */ public class DateFormats { - public static Date parseDate(String value) { - return null; - } - + public static Date parseDate(String value) { + return null; + } } diff --git a/src/test/java/de/itc/utils/MapUtilities.java b/src/test/java/de/itc/utils/MapUtilities.java index 9afb2a8..5e5594a 100644 --- a/src/test/java/de/itc/utils/MapUtilities.java +++ b/src/test/java/de/itc/utils/MapUtilities.java @@ -20,22 +20,20 @@ package de.itc.utils; import com.fasterxml.jackson.databind.ObjectMapper; - import java.util.LinkedHashMap; /** - * Diese Klasse dient nur Testzwecken, da die Klasse und enthaltene(n) Methode(n) von der Onkostar-API - * benötigt und verwendet werden, nicht jedoch in der Onkostar-API-JAR enthalten sind. + * Diese Klasse dient nur Testzwecken, da die Klasse und enthaltene(n) Methode(n) von der + * Onkostar-API benötigt und verwendet werden, nicht jedoch in der Onkostar-API-JAR enthalten sind. * Das tatsächliche Verhalten innerhalb von Onkostar wird abweichen. */ public class MapUtilities { - public static ObjectMapper getObjectMapper() { - return null; - } - - public static LinkedHashMap stringToMap(String value) { - return null; - } + public static ObjectMapper getObjectMapper() { + return null; + } + public static LinkedHashMap stringToMap(String value) { + return null; + } } diff --git a/src/test/java/dev/dnpm/oshelper/ConsentManagerTest.java b/src/test/java/dev/dnpm/oshelper/ConsentManagerTest.java index b0dc6a9..80e7298 100644 --- a/src/test/java/dev/dnpm/oshelper/ConsentManagerTest.java +++ b/src/test/java/dev/dnpm/oshelper/ConsentManagerTest.java @@ -19,64 +19,62 @@ package dev.dnpm.oshelper; +import static org.mockito.Mockito.*; + +import de.itc.onkostar.api.IOnkostarApi; +import de.itc.onkostar.api.Procedure; import dev.dnpm.oshelper.analyzer.ConsentManager; import dev.dnpm.oshelper.services.consent.ConsentManagerServiceFactory; import dev.dnpm.oshelper.services.consent.MrConsentManagerService; -import de.itc.onkostar.api.IOnkostarApi; -import de.itc.onkostar.api.Procedure; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class ConsentManagerTest { - private IOnkostarApi onkostarApi; - - private ConsentManagerServiceFactory consentManagerServiceFactory; + private IOnkostarApi onkostarApi; - private ConsentManager consentManager; + private ConsentManagerServiceFactory consentManagerServiceFactory; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock ConsentManagerServiceFactory consentManagerServiceFactory - ) { - this.onkostarApi = onkostarApi; - this.consentManagerServiceFactory = consentManagerServiceFactory; - this.consentManager = new ConsentManager(onkostarApi, consentManagerServiceFactory); - } + private ConsentManager consentManager; - @Test - void shouldRunServiceMethodsOnAnalyzeCalled() { - var consentManagerServiceMock = mock(MrConsentManagerService.class); + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock ConsentManagerServiceFactory consentManagerServiceFactory) { + this.onkostarApi = onkostarApi; + this.consentManagerServiceFactory = consentManagerServiceFactory; + this.consentManager = new ConsentManager(onkostarApi, consentManagerServiceFactory); + } - when(consentManagerServiceMock.canApply(any(Procedure.class))).thenReturn(true); + @Test + void shouldRunServiceMethodsOnAnalyzeCalled() { + var consentManagerServiceMock = mock(MrConsentManagerService.class); - when(this.consentManagerServiceFactory.currentUsableInstance()) - .thenReturn(consentManagerServiceMock); + when(consentManagerServiceMock.canApply(any(Procedure.class))).thenReturn(true); - this.consentManager.analyze(new Procedure(onkostarApi), null); + when(this.consentManagerServiceFactory.currentUsableInstance()) + .thenReturn(consentManagerServiceMock); - verify(consentManagerServiceMock, times(1)).applyConsent(any(Procedure.class)); - } + this.consentManager.analyze(new Procedure(onkostarApi), null); - @Test - void shouldNotRunServiceMethodsIfProcedureCannotBeAppliesForForm() { - var consentManagerServiceMock = mock(MrConsentManagerService.class); + verify(consentManagerServiceMock, times(1)).applyConsent(any(Procedure.class)); + } - when(consentManagerServiceMock.canApply(any(Procedure.class))).thenReturn(false); + @Test + void shouldNotRunServiceMethodsIfProcedureCannotBeAppliesForForm() { + var consentManagerServiceMock = mock(MrConsentManagerService.class); - when(this.consentManagerServiceFactory.currentUsableInstance()) - .thenReturn(consentManagerServiceMock); + when(consentManagerServiceMock.canApply(any(Procedure.class))).thenReturn(false); - this.consentManager.analyze(new Procedure(onkostarApi), null); + when(this.consentManagerServiceFactory.currentUsableInstance()) + .thenReturn(consentManagerServiceMock); - verify(consentManagerServiceMock, times(0)).applyConsent(any(Procedure.class)); - } + this.consentManager.analyze(new Procedure(onkostarApi), null); + verify(consentManagerServiceMock, times(0)).applyConsent(any(Procedure.class)); + } } diff --git a/src/test/java/dev/dnpm/oshelper/DNPMHelperTest.java b/src/test/java/dev/dnpm/oshelper/DNPMHelperTest.java index 839db4c..87f1771 100644 --- a/src/test/java/dev/dnpm/oshelper/DNPMHelperTest.java +++ b/src/test/java/dev/dnpm/oshelper/DNPMHelperTest.java @@ -19,15 +19,23 @@ package dev.dnpm.oshelper; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; + +import de.itc.onkostar.api.IOnkostarApi; +import de.itc.onkostar.api.Item; +import de.itc.onkostar.api.Patient; +import de.itc.onkostar.api.Procedure; import dev.dnpm.oshelper.analyzer.DNPMHelper; import dev.dnpm.oshelper.security.DelegatingDataBasedPermissionEvaluator; import dev.dnpm.oshelper.security.IllegalSecuredObjectAccessException; import dev.dnpm.oshelper.security.PermissionType; import dev.dnpm.oshelper.services.systemtherapie.SystemtherapieService; -import de.itc.onkostar.api.IOnkostarApi; -import de.itc.onkostar.api.Item; -import de.itc.onkostar.api.Patient; -import de.itc.onkostar.api.Procedure; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.SessionFactory; @@ -39,154 +47,149 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.Date; -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.Mockito.*; - @ExtendWith(MockitoExtension.class) class DNPMHelperTest { - private IOnkostarApi onkostarApi; + private IOnkostarApi onkostarApi; - private SystemtherapieService systemtherapieService; + private SystemtherapieService systemtherapieService; - private DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator; + private DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator; - private DNPMHelper dnpmHelper; + private DNPMHelper dnpmHelper; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock SystemtherapieService systemtherapieService, - @Mock DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator - ) { - this.onkostarApi = onkostarApi; - this.systemtherapieService = systemtherapieService; - this.delegatingDataBasedPermissionEvaluator = delegatingDataBasedPermissionEvaluator; - this.dnpmHelper = new DNPMHelper(onkostarApi, systemtherapieService, delegatingDataBasedPermissionEvaluator); - } + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock SystemtherapieService systemtherapieService, + @Mock DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator) { + this.onkostarApi = onkostarApi; + this.systemtherapieService = systemtherapieService; + this.delegatingDataBasedPermissionEvaluator = delegatingDataBasedPermissionEvaluator; + this.dnpmHelper = + new DNPMHelper(onkostarApi, systemtherapieService, delegatingDataBasedPermissionEvaluator); + } + + @Test + void testShouldRequestSystemischeTherapienFromDiagnose() { + dnpmHelper.getSystemischeTherapienFromDiagnose(Map.of("DiagnoseId", 1234)); + + var captor = ArgumentCaptor.forClass(Integer.class); + verify(systemtherapieService, times(1)).getSystemischeTherapienFromDiagnose(captor.capture()); + assertThat(captor.getValue()).isEqualTo(1234); + } + + @Test + void testShouldReturnNullIfNoDiagnoseIdCallingGetSystemischeTherapienFromDiagnose() { + var actual = dnpmHelper.getSystemischeTherapienFromDiagnose(new HashMap<>()); + + assertThat(actual).isNull(); + } + + @Test + void testShouldReturnNullIfNoProcedureIdCallingGetEmpfehlung() { + var actual = dnpmHelper.getEmpfehlung(new HashMap<>()); + + assertThat(actual).isNull(); + } + + @Nested + class UpdateEmpfehlungPrioTests { @Test - void testShouldRequestSystemischeTherapienFromDiagnose() { - dnpmHelper.getSystemischeTherapienFromDiagnose(Map.of("DiagnoseId", 1234)); + void testShouldReturnFalseIfNoRidAndNoBdCallingUpdateEmpfehlungPrio() { + var actual = dnpmHelper.updateEmpfehlungPrio(new HashMap<>()); - var captor = ArgumentCaptor.forClass(Integer.class); - verify(systemtherapieService, times(1)).getSystemischeTherapienFromDiagnose(captor.capture()); - assertThat(captor.getValue()).isEqualTo(1234); + assertThat(actual).isEqualTo(false); } @Test - void testShouldReturnNullIfNoDiagnoseIdCallingGetSystemischeTherapienFromDiagnose() { - var actual = dnpmHelper.getSystemischeTherapienFromDiagnose(new HashMap<>()); + void testShouldReturnFalseIfNoRidCallingUpdateEmpfehlungPrio() { + var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("bd", "2023-01-01")); - assertThat(actual).isNull(); + assertThat(actual).isEqualTo(false); } @Test - void testShouldReturnNullIfNoProcedureIdCallingGetEmpfehlung() { - var actual = dnpmHelper.getEmpfehlung(new HashMap<>()); + void testShouldReturnFalseIfNoBdCallingUpdateEmpfehlungPrio() { + var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234)); - assertThat(actual).isNull(); + assertThat(actual).isEqualTo(false); } - @Nested - class UpdateEmpfehlungPrioTests { - - @Test - void testShouldReturnFalseIfNoRidAndNoBdCallingUpdateEmpfehlungPrio() { - var actual = dnpmHelper.updateEmpfehlungPrio(new HashMap<>()); + @Test + void testShouldReturnTrueIfRidAndBdPresentCallingUpdateEmpfehlungPrio() { + var sessionFactory = mock(SessionFactory.class); + var session = mock(Session.class); + var query = mock(SQLQuery.class); - assertThat(actual).isEqualTo(false); - } + when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); + when(sessionFactory.getCurrentSession()).thenReturn(session); + when(session.createSQLQuery(anyString())).thenReturn(query); - @Test - void testShouldReturnFalseIfNoRidCallingUpdateEmpfehlungPrio() { - var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("bd", "2023-01-01")); + var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234, "bd", "2023-01-01")); - assertThat(actual).isEqualTo(false); - } + assertThat(actual).isEqualTo(true); + } - @Test - void testShouldReturnFalseIfNoBdCallingUpdateEmpfehlungPrio() { - var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234)); + @Test + void testShouldCreateSqlQueryWithRidAndBdCallingUpdateEmpfehlungPrio() { + var sessionFactory = mock(SessionFactory.class); + var session = mock(Session.class); + var query = mock(SQLQuery.class); - assertThat(actual).isEqualTo(false); - } + when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); + when(sessionFactory.getCurrentSession()).thenReturn(session); + when(session.createSQLQuery(anyString())).thenReturn(query); - @Test - void testShouldReturnTrueIfRidAndBdPresentCallingUpdateEmpfehlungPrio() { - var sessionFactory = mock(SessionFactory.class); - var session = mock(Session.class); - var query = mock(SQLQuery.class); + dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234, "bd", "2023-01-01")); - when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); - when(sessionFactory.getCurrentSession()).thenReturn(session); - when(session.createSQLQuery(anyString())).thenReturn(query); + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()) + .isEqualTo("UPDATE prozedur SET beginndatum = '2023-01-01' WHERE id = '1234' "); + } + } - var actual = dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234, "bd", "2023-01-01")); + @Nested + class GetProzedurenFromDiagnoseTests { + @Test + void testShouldReturnEmptyStringOnParamCheckIfNoDataFormParamGiven() { + var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("DiagnoseId", 1, "PatientId", 2)); + assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - assertThat(actual).isEqualTo(true); - } + verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); + } - @Test - void testShouldCreateSqlQueryWithRidAndBdCallingUpdateEmpfehlungPrio() { - var sessionFactory = mock(SessionFactory.class); - var session = mock(Session.class); - var query = mock(SQLQuery.class); + @Test + void testShouldReturnEmptyStringOnParamCheckIfNoDiagnoseIdParamGiven() { + var actual = + dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "PatientId", 2)); + assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); - when(sessionFactory.getCurrentSession()).thenReturn(session); - when(session.createSQLQuery(anyString())).thenReturn(query); + verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); + } - dnpmHelper.updateEmpfehlungPrio(Map.of("rid", 1234, "bd", "2023-01-01")); + @Test + void testShouldReturnEmptyStringOnParamCheckIfNoPatientIdParamGiven() { + var actual = + dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "DiagnoseId", 1)); + assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).isEqualTo("UPDATE prozedur SET beginndatum = '2023-01-01' WHERE id = '1234' "); - } + verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); + } + @Test + void testShouldRequestProceduresIfRequiredParamsGiven() { + dnpmHelper.getProzedurenFromDiagnose( + Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); + verify(onkostarApi, times(1)).getProceduresByPatientId(anyInt()); } - @Nested - class GetProzedurenFromDiagnoseTests { - @Test - void testShouldReturnEmptyStringOnParamCheckIfNoDataFormParamGiven() { - var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("DiagnoseId", 1, "PatientId", 2)); - assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - - verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); - } - - @Test - void testShouldReturnEmptyStringOnParamCheckIfNoDiagnoseIdParamGiven() { - var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "PatientId", 2)); - assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - - verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); - } - - @Test - void testShouldReturnEmptyStringOnParamCheckIfNoPatientIdParamGiven() { - var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "DiagnoseId", 1)); - assertThat(actual).isExactlyInstanceOf(String.class).isEmpty(); - - verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); - } - - @Test - void testShouldRequestProceduresIfRequiredParamsGiven() { - dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); - verify(onkostarApi, times(1)).getProceduresByPatientId(anyInt()); - } - - @Test - void testShouldNotReturnProceduresNotRelatedToDisease() { - doAnswer(invocationOnMock -> { + @Test + void testShouldNotReturnProceduresNotRelatedToDisease() { + doAnswer( + invocationOnMock -> { var procedure = new Procedure(onkostarApi); procedure.setFormName("OS.Example1"); procedure.setId(11); @@ -194,15 +197,20 @@ class DNPMHelperTest { procedure.setValue("formfield", new Item("formfield", "Wert11")); return List.of(procedure); - }).when(onkostarApi).getProceduresByPatientId(anyInt()); - - var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); - assertThat(actual).isEqualTo("[]"); - } + }) + .when(onkostarApi) + .getProceduresByPatientId(anyInt()); + + var actual = + dnpmHelper.getProzedurenFromDiagnose( + Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); + assertThat(actual).isEqualTo("[]"); + } - @Test - void testShouldReturnProcedures() { - doAnswer(invocationOnMock -> { + @Test + void testShouldReturnProcedures() { + doAnswer( + invocationOnMock -> { var procedure1 = new Procedure(onkostarApi); procedure1.setFormName("OS.Example1"); procedure1.setId(11); @@ -225,90 +233,102 @@ class DNPMHelperTest { procedure3.setValue("formfield", new Item("formfield", "Wert12")); return List.of(procedure1, procedure2, procedure3); - }).when(onkostarApi).getProceduresByPatientId(anyInt()); - - var actual = dnpmHelper.getProzedurenFromDiagnose(Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); - assertThat(actual).contains("OS.Example1", "OS.Example2", "Wert11", "Wert21", "Wert12"); - } + }) + .when(onkostarApi) + .getProceduresByPatientId(anyInt()); + + var actual = + dnpmHelper.getProzedurenFromDiagnose( + Map.of("dataForm", "OS.Example", "DiagnoseId", 1, "PatientId", 2)); + assertThat(actual).contains("OS.Example1", "OS.Example2", "Wert11", "Wert21", "Wert12"); } + } - @Nested - class GetVerweiseTests { + @Nested + class GetVerweiseTests { - @Test - void testShouldReturnEmptyArrayIfNoProcedureIdParamGiven() { - var actual = dnpmHelper.getVerweise(Map.of("PatientId", 2)); - assertThat(actual).isNull(); + @Test + void testShouldReturnEmptyArrayIfNoProcedureIdParamGiven() { + var actual = dnpmHelper.getVerweise(Map.of("PatientId", 2)); + assertThat(actual).isNull(); - verify(onkostarApi, times(0)).getSessionFactory(); - } + verify(onkostarApi, times(0)).getSessionFactory(); + } - @Test - void testShouldReturnEmptyArrayIfNoPatientIdParamGiven() { - var actual = dnpmHelper.getVerweise(Map.of("ProcedureId", 1)); - assertThat(actual).isNull(); + @Test + void testShouldReturnEmptyArrayIfNoPatientIdParamGiven() { + var actual = dnpmHelper.getVerweise(Map.of("ProcedureId", 1)); + assertThat(actual).isNull(); - verify(onkostarApi, times(0)).getSessionFactory(); - } + verify(onkostarApi, times(0)).getSessionFactory(); + } - @Test - void testShouldRequestSessionFactoryIfRequiredParamsGiven() { - dnpmHelper.getVerweise(Map.of("ProcedureId", 1, "PatientId", 2)); - verify(onkostarApi, times(1)).getSessionFactory(); - } + @Test + void testShouldRequestSessionFactoryIfRequiredParamsGiven() { + dnpmHelper.getVerweise(Map.of("ProcedureId", 1, "PatientId", 2)); + verify(onkostarApi, times(1)).getSessionFactory(); + } - @Test - void testShouldCreateSqlQueryWithPatientId() { - var sessionFactory = mock(SessionFactory.class); - var session = mock(Session.class); - var query = mock(SQLQuery.class); + @Test + void testShouldCreateSqlQueryWithPatientId() { + var sessionFactory = mock(SessionFactory.class); + var session = mock(Session.class); + var query = mock(SQLQuery.class); - when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); - when(sessionFactory.getCurrentSession()).thenReturn(session); - when(session.createSQLQuery(anyString())).thenReturn(query); + when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); + when(sessionFactory.getCurrentSession()).thenReturn(session); + when(session.createSQLQuery(anyString())).thenReturn(query); - dnpmHelper.getVerweise(Map.of("ProcedureId", 1, "PatientId", 2)); + dnpmHelper.getVerweise(Map.of("ProcedureId", 1, "PatientId", 2)); - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).contains("WHERE patient_id = 2 AND geloescht = 0"); - } + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).contains("WHERE patient_id = 2 AND geloescht = 0"); + } - @Test - void testShouldReturnEcogStatusList() { - when(delegatingDataBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(true); + @Test + void testShouldReturnEcogStatusList() { + when(delegatingDataBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); - doAnswer(invocationOnMock -> { + doAnswer( + invocationOnMock -> { var id = invocationOnMock.getArgument(0, Integer.class); var patient = new Patient(onkostarApi); patient.setId(id); return patient; - }).when(onkostarApi).getPatient(anyInt()); + }) + .when(onkostarApi) + .getPatient(anyInt()); - dnpmHelper.getEcogStatus(Map.of("PatientId", 42)); + dnpmHelper.getEcogStatus(Map.of("PatientId", 42)); - var argumentCaptor = ArgumentCaptor.forClass(Patient.class); - verify(systemtherapieService, times(1)).ecogStatus(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).isNotNull(); - assertThat(argumentCaptor.getValue().getId()).isEqualTo(42); - } + var argumentCaptor = ArgumentCaptor.forClass(Patient.class); + verify(systemtherapieService, times(1)).ecogStatus(argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).isNotNull(); + assertThat(argumentCaptor.getValue().getId()).isEqualTo(42); + } - @Test - void testShouldNotReturnEcogStatusListIfNoPermissionGranted() { - when(delegatingDataBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(false); + @Test + void testShouldNotReturnEcogStatusListIfNoPermissionGranted() { + when(delegatingDataBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(false); - doAnswer(invocationOnMock -> { + doAnswer( + invocationOnMock -> { var id = invocationOnMock.getArgument(0, Integer.class); var patient = new Patient(onkostarApi); patient.setId(id); return patient; - }).when(onkostarApi).getPatient(anyInt()); - - assertThrows(IllegalSecuredObjectAccessException.class, () -> dnpmHelper.getEcogStatus(Map.of("PatientId", 42))); - } + }) + .when(onkostarApi) + .getPatient(anyInt()); + assertThrows( + IllegalSecuredObjectAccessException.class, + () -> dnpmHelper.getEcogStatus(Map.of("PatientId", 42))); } - + } } diff --git a/src/test/java/dev/dnpm/oshelper/MerkmalskatalogTest.java b/src/test/java/dev/dnpm/oshelper/MerkmalskatalogTest.java index f57dd8f..e393d17 100644 --- a/src/test/java/dev/dnpm/oshelper/MerkmalskatalogTest.java +++ b/src/test/java/dev/dnpm/oshelper/MerkmalskatalogTest.java @@ -19,8 +19,12 @@ package dev.dnpm.oshelper; -import dev.dnpm.oshelper.analyzer.Merkmalskatalog; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; +import dev.dnpm.oshelper.analyzer.Merkmalskatalog; +import java.util.Map; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.SessionFactory; @@ -31,57 +35,49 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class MerkmalskatalogTest { - private IOnkostarApi onkostarApi; - - private Merkmalskatalog merkmalskatalog; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.merkmalskatalog = new Merkmalskatalog(onkostarApi); - } + private Merkmalskatalog merkmalskatalog; - @Test - void testShouldReturnNullOnParamCheckIfNoMerkmalskatalogParamGiven() { - var actual = merkmalskatalog.getMerkmalskatalog(Map.of("Spalten", "id, code")); - assertThat(actual).isNull(); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.merkmalskatalog = new Merkmalskatalog(onkostarApi); + } - verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); - } + @Test + void testShouldReturnNullOnParamCheckIfNoMerkmalskatalogParamGiven() { + var actual = merkmalskatalog.getMerkmalskatalog(Map.of("Spalten", "id, code")); + assertThat(actual).isNull(); - @Test - void testShouldReturnNullOnParamCheckIfNoSpaltenParamGiven() { - var actual = merkmalskatalog.getMerkmalskatalog(Map.of("Merkmalskatalog", "MK1")); - assertThat(actual).isNull(); + verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); + } - verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); - } + @Test + void testShouldReturnNullOnParamCheckIfNoSpaltenParamGiven() { + var actual = merkmalskatalog.getMerkmalskatalog(Map.of("Merkmalskatalog", "MK1")); + assertThat(actual).isNull(); - @Test - void testShouldCreateSqlQueryWithMerkmalskatalog() { - var sessionFactory = mock(SessionFactory.class); - var session = mock(Session.class); - var query = mock(SQLQuery.class); + verify(onkostarApi, times(0)).getProceduresByPatientId(anyInt()); + } - when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); - when(sessionFactory.getCurrentSession()).thenReturn(session); - when(session.createSQLQuery(anyString())).thenReturn(query); + @Test + void testShouldCreateSqlQueryWithMerkmalskatalog() { + var sessionFactory = mock(SessionFactory.class); + var session = mock(Session.class); + var query = mock(SQLQuery.class); - merkmalskatalog.getMerkmalskatalog(Map.of("Merkmalskatalog", "MK1", "Spalten", "id, code")); + when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); + when(sessionFactory.getCurrentSession()).thenReturn(session); + when(session.createSQLQuery(anyString())).thenReturn(query); - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).contains("WHERE name = 'MK1' AND aktiv = 1"); - } + merkmalskatalog.getMerkmalskatalog(Map.of("Merkmalskatalog", "MK1", "Spalten", "id, code")); + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(session, times(1)).createSQLQuery(argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).contains("WHERE name = 'MK1' AND aktiv = 1"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/analyzer/AnalyzerUtilsTest.java b/src/test/java/dev/dnpm/oshelper/analyzer/AnalyzerUtilsTest.java index 009ce34..18100a6 100644 --- a/src/test/java/dev/dnpm/oshelper/analyzer/AnalyzerUtilsTest.java +++ b/src/test/java/dev/dnpm/oshelper/analyzer/AnalyzerUtilsTest.java @@ -19,138 +19,141 @@ package dev.dnpm.oshelper.analyzer; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; +import static org.assertj.core.api.Assertions.assertThat; import java.util.Map; import java.util.Optional; import java.util.Set; - -import static org.assertj.core.api.Assertions.assertThat; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; class AnalyzerUtilsTest { - private final Map input = Map.of("value1", 1, "valueA", "A", "valueTrue", true); - - private static Set testTypeData() { - return Set.of( - new TestTypeData("value1", Integer.class).withExpectedResult(true), - new TestTypeData("valueA", String.class).withExpectedResult(true), - new TestTypeData("valueTrue", Boolean.class).withExpectedResult(true), - - new TestTypeData("value1", String.class).withExpectedResult(false), - new TestTypeData("valueA", Boolean.class).withExpectedResult(false), - new TestTypeData("valueTrue", Integer.class).withExpectedResult(false), - - new TestTypeData("value1", Boolean.class).withExpectedResult(false), - new TestTypeData("valueA", Integer.class).withExpectedResult(false), - new TestTypeData("valueTrue", String.class).withExpectedResult(false) - ); + private final Map input = Map.of("value1", 1, "valueA", "A", "valueTrue", true); + + private static Set testTypeData() { + return Set.of( + new TestTypeData("value1", Integer.class).withExpectedResult(true), + new TestTypeData("valueA", String.class).withExpectedResult(true), + new TestTypeData("valueTrue", Boolean.class).withExpectedResult(true), + new TestTypeData("value1", String.class).withExpectedResult(false), + new TestTypeData("valueA", Boolean.class).withExpectedResult(false), + new TestTypeData("valueTrue", Integer.class).withExpectedResult(false), + new TestTypeData("value1", Boolean.class).withExpectedResult(false), + new TestTypeData("valueA", Integer.class).withExpectedResult(false), + new TestTypeData("valueTrue", String.class).withExpectedResult(false)); + } + + @ParameterizedTest + @MethodSource("testTypeData") + void testShouldReturnExpectedResultForTypedCheck(TestTypeData testData) { + var actual = AnalyzerUtils.requiredValuePresent(input, testData.key, testData.type); + assertThat(actual).isEqualTo(testData.result); + } + + private static Set testMatchData() { + return Set.of( + new TestMatchData("value1", "[\\d]").withExpectedResult(true), + new TestMatchData("valueA", "[A-Z]").withExpectedResult(true), + new TestMatchData("value1", "[A-Z]").withExpectedResult(false), + new TestMatchData("valueA", "[a-z]").withExpectedResult(false), + new TestMatchData("valueA", "[\\d]").withExpectedResult(false)); + } + + @ParameterizedTest + @MethodSource("testMatchData") + void testShouldReturnExpectedResultForMatchCheck(TestMatchData testData) { + var actual = AnalyzerUtils.requiredValueMatches(input, testData.key, testData.regexp); + assertThat(actual).isEqualTo(testData.result); + } + + @Test + void testShouldCheckIfInputValueIsIdNumber() { + assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", 0), "value")).isFalse(); + assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", "ABC"), "value")).isFalse(); + assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", 1234), "value")).isTrue(); + } + + @Test + void testShouldReturnInputValueAsOptional() { + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value", Integer.class)) + .isEqualTo(Optional.of(1234)); + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value", String.class)) + .isEqualTo(Optional.of("ABC")); + + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value1", Integer.class)) + .isEmpty(); + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value1", String.class)) + .isEmpty(); + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value", String.class)) + .isEmpty(); + assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value", Boolean.class)) + .isEmpty(); + } + + @Test + void testShouldReturnInputIdAsOptional() { + assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 1234), "value")) + .isEqualTo(Optional.of(1234)); + + assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 1234), "value1")).isEmpty(); + assertThat(AnalyzerUtils.getRequiredId(Map.of("value", "ABC"), "value")).isEmpty(); + assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 0), "value")).isEmpty(); + } + + @Test + void testShouldReturnInputValueMatchingAsOptional() { + assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", 1234), "value", "[\\d]+")) + .isEqualTo(Optional.of("1234")); + assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", "ABC"), "value", "[A-Z]+")) + .isEqualTo(Optional.of("ABC")); + + assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", "ABC"), "value1", "[A-Z]+")) + .isEmpty(); + } + + private static class TestTypeData { + public final String key; + public final Class type; + + public boolean result; + + public TestTypeData(String key, Class type) { + this.key = key; + this.type = type; } - @ParameterizedTest - @MethodSource("testTypeData") - void testShouldReturnExpectedResultForTypedCheck(TestTypeData testData) { - var actual = AnalyzerUtils.requiredValuePresent(input, testData.key, testData.type); - assertThat(actual).isEqualTo(testData.result); + public TestTypeData withExpectedResult(boolean result) { + this.result = result; + return this; } - private static Set testMatchData() { - return Set.of( - new TestMatchData("value1", "[\\d]").withExpectedResult(true), - new TestMatchData("valueA", "[A-Z]").withExpectedResult(true), - - new TestMatchData("value1", "[A-Z]").withExpectedResult(false), - new TestMatchData("valueA", "[a-z]").withExpectedResult(false), - new TestMatchData("valueA", "[\\d]").withExpectedResult(false) - ); - } - - @ParameterizedTest - @MethodSource("testMatchData") - void testShouldReturnExpectedResultForMatchCheck(TestMatchData testData) { - var actual = AnalyzerUtils.requiredValueMatches(input, testData.key, testData.regexp); - assertThat(actual).isEqualTo(testData.result); + @Override + public String toString() { + return String.format("key: '%s', type: %s, result: %s", key, type.getSimpleName(), result); } + } - @Test - void testShouldCheckIfInputValueIsIdNumber() { - assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", 0), "value")).isFalse(); - assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", "ABC"), "value")).isFalse(); - assertThat(AnalyzerUtils.requiredValueIsId(Map.of("value", 1234), "value")).isTrue(); - } + private static class TestMatchData { + public final String key; + public final String regexp; - @Test - void testShouldReturnInputValueAsOptional() { - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value", Integer.class)).isEqualTo(Optional.of(1234)); - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value", String.class)).isEqualTo(Optional.of("ABC")); + public boolean result; - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value1", Integer.class)).isEmpty(); - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value1", String.class)).isEmpty(); - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", 1234), "value", String.class)).isEmpty(); - assertThat(AnalyzerUtils.getRequiredValue(Map.of("value", "ABC"), "value", Boolean.class)).isEmpty(); + public TestMatchData(String key, String regexp) { + this.key = key; + this.regexp = regexp; } - @Test - void testShouldReturnInputIdAsOptional() { - assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 1234), "value")).isEqualTo(Optional.of(1234)); - - assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 1234), "value1")).isEmpty(); - assertThat(AnalyzerUtils.getRequiredId(Map.of("value", "ABC"), "value")).isEmpty(); - assertThat(AnalyzerUtils.getRequiredId(Map.of("value", 0), "value")).isEmpty(); - } - - @Test - void testShouldReturnInputValueMatchingAsOptional() { - assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", 1234), "value", "[\\d]+")).isEqualTo(Optional.of("1234")); - assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", "ABC"), "value", "[A-Z]+")).isEqualTo(Optional.of("ABC")); - - assertThat(AnalyzerUtils.getRequiredValueMatching(Map.of("value", "ABC"), "value1", "[A-Z]+")).isEmpty(); + public TestMatchData withExpectedResult(boolean result) { + this.result = result; + return this; } - private static class TestTypeData { - public final String key; - public final Class type; - - public boolean result; - - public TestTypeData(String key, Class type) { - this.key = key; - this.type = type; - } - - public TestTypeData withExpectedResult(boolean result) { - this.result = result; - return this; - } - - @Override - public String toString() { - return String.format("key: '%s', type: %s, result: %s", key, type.getSimpleName(), result); - } + @Override + public String toString() { + return String.format("key: '%s', regexp: '%s', result: %s", key, regexp, result); } - - private static class TestMatchData { - public final String key; - public final String regexp; - - public boolean result; - - public TestMatchData(String key, String regexp) { - this.key = key; - this.regexp = regexp; - } - - public TestMatchData withExpectedResult(boolean result) { - this.result = result; - return this; - } - - @Override - public String toString() { - return String.format("key: '%s', regexp: '%s', result: %s", key, regexp, result); - } - } - + } } diff --git a/src/test/java/dev/dnpm/oshelper/analyzer/EinzelempfehlungAnalyzerTest.java b/src/test/java/dev/dnpm/oshelper/analyzer/EinzelempfehlungAnalyzerTest.java index 092e85d..3e33574 100644 --- a/src/test/java/dev/dnpm/oshelper/analyzer/EinzelempfehlungAnalyzerTest.java +++ b/src/test/java/dev/dnpm/oshelper/analyzer/EinzelempfehlungAnalyzerTest.java @@ -19,12 +19,17 @@ package dev.dnpm.oshelper.analyzer; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + +import de.itc.onkostar.api.IOnkostarApi; +import de.itc.onkostar.api.Procedure; import dev.dnpm.oshelper.security.PermissionType; import dev.dnpm.oshelper.security.PersonPoolBasedPermissionEvaluator; import dev.dnpm.oshelper.services.StudienService; import dev.dnpm.oshelper.services.molekulargenetik.MolekulargenetikFormService; -import de.itc.onkostar.api.IOnkostarApi; -import de.itc.onkostar.api.Procedure; +import java.util.HashMap; +import java.util.Map; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -32,91 +37,88 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.HashMap; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class EinzelempfehlungAnalyzerTest { - private IOnkostarApi onkostarApi; - - private StudienService studienService; - - private MolekulargenetikFormService molekulargenetikFormService; - - private PersonPoolBasedPermissionEvaluator permissionEvaluator; - - private EinzelempfehlungAnalyzer analyzer; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock StudienService studienService, - @Mock MolekulargenetikFormService molekulargenetikFormService, - @Mock PersonPoolBasedPermissionEvaluator permissionEvaluator - ) { - this.onkostarApi = onkostarApi; - this.studienService = studienService; - this.molekulargenetikFormService = molekulargenetikFormService; - this.permissionEvaluator = permissionEvaluator; - this.analyzer = new EinzelempfehlungAnalyzer(onkostarApi, studienService, molekulargenetikFormService, permissionEvaluator); - } - - @Test - void testShouldRequestVariantsFromMolekulargenetikFormService() { - doAnswer(invocationOnMock -> new Procedure(this.onkostarApi)).when(onkostarApi).getProcedure(anyInt()); - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(true); - - analyzer.getVariants(Map.of("id", 123)); - verify(molekulargenetikFormService, times(1)).getVariants(any(Procedure.class)); - } - - @Test - void shouldRequestAllStudienForEmptyQueryString() { - var input = Map.of("q", (Object) " "); - this.analyzer.getStudien(input); - - verify(studienService, times(1)).findActive(); - } - - @Test - void shouldRequestActiveStudienForEmptyInputMap() { - var input = new HashMap(); - this.analyzer.getStudien(input); - - verify(studienService, times(1)).findActive(); - } - - @Test - void shouldRequestFilteredActiveStudien() { - var input = Map.of("q", (Object) "NCT-123"); - this.analyzer.getStudien(input); - - var captor = ArgumentCaptor.forClass(String.class); - verify(studienService, times(1)).findActiveByQuery(captor.capture()); - assertThat(captor.getValue()).isEqualTo("NCT-123"); - } - - @Test - void shouldRequestActiveStudien() { - var input = Map.of("q", (Object) ""); - this.analyzer.getStudien(input); - - verify(studienService, times(1)).findActive(); - } - - @Test - void shouldRequestAllFilteredtudien() { - var input = Map.of("q", (Object) "NCT-123"); - this.analyzer.getStudien(input); - - var captor = ArgumentCaptor.forClass(String.class); - verify(studienService, times(1)).findActiveByQuery(captor.capture()); - assertThat(captor.getValue()).isEqualTo("NCT-123"); - } - + private IOnkostarApi onkostarApi; + + private StudienService studienService; + + private MolekulargenetikFormService molekulargenetikFormService; + + private PersonPoolBasedPermissionEvaluator permissionEvaluator; + + private EinzelempfehlungAnalyzer analyzer; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock StudienService studienService, + @Mock MolekulargenetikFormService molekulargenetikFormService, + @Mock PersonPoolBasedPermissionEvaluator permissionEvaluator) { + this.onkostarApi = onkostarApi; + this.studienService = studienService; + this.molekulargenetikFormService = molekulargenetikFormService; + this.permissionEvaluator = permissionEvaluator; + this.analyzer = + new EinzelempfehlungAnalyzer( + onkostarApi, studienService, molekulargenetikFormService, permissionEvaluator); + } + + @Test + void testShouldRequestVariantsFromMolekulargenetikFormService() { + doAnswer(invocationOnMock -> new Procedure(this.onkostarApi)) + .when(onkostarApi) + .getProcedure(anyInt()); + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(true); + + analyzer.getVariants(Map.of("id", 123)); + verify(molekulargenetikFormService, times(1)).getVariants(any(Procedure.class)); + } + + @Test + void shouldRequestAllStudienForEmptyQueryString() { + var input = Map.of("q", (Object) " "); + this.analyzer.getStudien(input); + + verify(studienService, times(1)).findActive(); + } + + @Test + void shouldRequestActiveStudienForEmptyInputMap() { + var input = new HashMap(); + this.analyzer.getStudien(input); + + verify(studienService, times(1)).findActive(); + } + + @Test + void shouldRequestFilteredActiveStudien() { + var input = Map.of("q", (Object) "NCT-123"); + this.analyzer.getStudien(input); + + var captor = ArgumentCaptor.forClass(String.class); + verify(studienService, times(1)).findActiveByQuery(captor.capture()); + assertThat(captor.getValue()).isEqualTo("NCT-123"); + } + + @Test + void shouldRequestActiveStudien() { + var input = Map.of("q", (Object) ""); + this.analyzer.getStudien(input); + + verify(studienService, times(1)).findActive(); + } + + @Test + void shouldRequestAllFilteredtudien() { + var input = Map.of("q", (Object) "NCT-123"); + this.analyzer.getStudien(input); + + var captor = ArgumentCaptor.forClass(String.class); + verify(studienService, times(1)).findActiveByQuery(captor.capture()); + assertThat(captor.getValue()).isEqualTo("NCT-123"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/analyzer/FollowUpAnalyzerTest.java b/src/test/java/dev/dnpm/oshelper/analyzer/FollowUpAnalyzerTest.java index ee06c35..3a9b03f 100644 --- a/src/test/java/dev/dnpm/oshelper/analyzer/FollowUpAnalyzerTest.java +++ b/src/test/java/dev/dnpm/oshelper/analyzer/FollowUpAnalyzerTest.java @@ -19,6 +19,9 @@ package dev.dnpm.oshelper.analyzer; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; @@ -29,71 +32,65 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class FollowUpAnalyzerTest { - private IOnkostarApi onkostarApi; - - private FollowUpAnalyzer followUpAnalyzer; + private IOnkostarApi onkostarApi; - @BeforeEach - void setUp( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.followUpAnalyzer = new FollowUpAnalyzer(onkostarApi); - } + private FollowUpAnalyzer followUpAnalyzer; - @Test - void shouldBacklinkEinzelempfehlungUsingOnkostarApi() throws Exception { - var einzelempfehlung = new Procedure(onkostarApi); - einzelempfehlung.setId(1234); + @BeforeEach + void setUp(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.followUpAnalyzer = new FollowUpAnalyzer(onkostarApi); + } - when(onkostarApi.getProcedure(anyInt())).thenReturn(einzelempfehlung); + @Test + void shouldBacklinkEinzelempfehlungUsingOnkostarApi() throws Exception { + var einzelempfehlung = new Procedure(onkostarApi); + einzelempfehlung.setId(1234); - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", 1234)); + when(onkostarApi.getProcedure(anyInt())).thenReturn(einzelempfehlung); - followUpAnalyzer.analyze(procedure, null); + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", 1234)); - var procedureIdCaptor = ArgumentCaptor.forClass(Integer.class); - verify(onkostarApi, times(1)).getProcedure(procedureIdCaptor.capture()); - assertThat(procedureIdCaptor.getValue()).isEqualTo(einzelempfehlung.getId()); + followUpAnalyzer.analyze(procedure, null); - var procedureCaptor = ArgumentCaptor.forClass(Procedure.class); - verify(onkostarApi, times(1)).saveProcedure(procedureCaptor.capture()); - assertThat(procedureCaptor.getValue()).isNotNull(); - assertThat(procedureCaptor.getValue().getId()).isEqualTo(einzelempfehlung.getId()); - } + var procedureIdCaptor = ArgumentCaptor.forClass(Integer.class); + verify(onkostarApi, times(1)).getProcedure(procedureIdCaptor.capture()); + assertThat(procedureIdCaptor.getValue()).isEqualTo(einzelempfehlung.getId()); - @Test - void shouldNotBacklinkEinzelempfehlungIfNoEinzelempfehlungSelected() throws Exception { - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); + var procedureCaptor = ArgumentCaptor.forClass(Procedure.class); + verify(onkostarApi, times(1)).saveProcedure(procedureCaptor.capture()); + assertThat(procedureCaptor.getValue()).isNotNull(); + assertThat(procedureCaptor.getValue().getId()).isEqualTo(einzelempfehlung.getId()); + } - followUpAnalyzer.analyze(procedure, null); + @Test + void shouldNotBacklinkEinzelempfehlungIfNoEinzelempfehlungSelected() throws Exception { + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); - verify(onkostarApi, times(0)).getProcedure(anyInt()); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class)); - } + followUpAnalyzer.analyze(procedure, null); - @Test - void shouldNotBacklinkEinzelempfehlungIfEinzelempfehlungDoesNotExist() throws Exception { - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", 1234)); + verify(onkostarApi, times(0)).getProcedure(anyInt()); + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class)); + } - followUpAnalyzer.analyze(procedure, null); + @Test + void shouldNotBacklinkEinzelempfehlungIfEinzelempfehlungDoesNotExist() throws Exception { + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", 1234)); - var procedureIdCaptor = ArgumentCaptor.forClass(Integer.class); - verify(onkostarApi, times(1)).getProcedure(procedureIdCaptor.capture()); - assertThat(procedureIdCaptor.getValue()).isEqualTo(1234); + followUpAnalyzer.analyze(procedure, null); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class)); - } + var procedureIdCaptor = ArgumentCaptor.forClass(Integer.class); + verify(onkostarApi, times(1)).getProcedure(procedureIdCaptor.capture()); + assertThat(procedureIdCaptor.getValue()).isEqualTo(1234); + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class)); + } } diff --git a/src/test/java/dev/dnpm/oshelper/analyzer/TherapieMitEcogAnalyzerTest.java b/src/test/java/dev/dnpm/oshelper/analyzer/TherapieMitEcogAnalyzerTest.java index c1f0b28..41a658a 100644 --- a/src/test/java/dev/dnpm/oshelper/analyzer/TherapieMitEcogAnalyzerTest.java +++ b/src/test/java/dev/dnpm/oshelper/analyzer/TherapieMitEcogAnalyzerTest.java @@ -19,10 +19,17 @@ package dev.dnpm.oshelper.analyzer; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + +import de.itc.onkostar.api.*; import dev.dnpm.oshelper.dto.EcogStatusWithDate; import dev.dnpm.oshelper.services.strahlentherapie.StrahlentherapieService; import dev.dnpm.oshelper.services.systemtherapie.SystemtherapieService; -import de.itc.onkostar.api.*; +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.Date; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -30,154 +37,153 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.time.temporal.ChronoUnit; -import java.util.Date; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class TherapieMitEcogAnalyzerTest { - private IOnkostarApi onkostarApi; - - private StrahlentherapieService strahlentherapieService; - - private SystemtherapieService systemtherapieService; - - private TherapieMitEcogAnalyzer therapieMitEcogAnalyzer; - - private Disease dummyDisease(int id, Date diagnosisDate) { - var disease = new Disease(onkostarApi); - disease.setId(id); - disease.setDiagnosisDate(diagnosisDate); - return disease; - } - - private Date daysPassed(int days) { - return Date.from(Instant.now().minus(days, ChronoUnit.DAYS)); - } - - @BeforeEach - void setUp( - @Mock IOnkostarApi onkostarApi, - @Mock StrahlentherapieService strahlentherapieService, - @Mock SystemtherapieService systemtherapieService - ) { - this.onkostarApi = onkostarApi; - this.strahlentherapieService = strahlentherapieService; - this.systemtherapieService = systemtherapieService; - this.therapieMitEcogAnalyzer = new TherapieMitEcogAnalyzer(onkostarApi, strahlentherapieService, systemtherapieService); - } - - @Test - void shouldInsertNewEcogStatus() throws Exception { - final var diagnosisDate = daysPassed(7); - final var ecogDate = daysPassed(1); - final var procedureDate = daysPassed(1); - - doAnswer(invocationOnMock -> List.of(new EcogStatusWithDate(ecogDate, "0"))) - .when(systemtherapieService).ecogStatus(any(Patient.class)); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setStartDate(procedureDate); - procedure.setEditState(ProcedureEditStateType.COMPLETED); - procedure.setPatientId(1); - procedure.setPatient(patient); - procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - doAnswer(invocationOnMock -> List.of(dummyDisease(42, diagnosisDate))).when(this.onkostarApi).getDiseasesByPatientId(anyInt()); - - doAnswer(invocationOnMock -> List.of(procedure)).when(onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); - - var idCaptor = ArgumentCaptor.forClass(Integer.class); - var formNameCaptor = ArgumentCaptor.forClass(String.class); - verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(idCaptor.capture(), formNameCaptor.capture()); - assertThat(idCaptor.getValue()).isEqualTo(42); - assertThat(formNameCaptor.getValue()).isEqualTo("DNPM Klinik/Anamnese"); - - verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void shouldNotModifyEcogStatusIfNoCompletedSystemTherapy() throws Exception { - final var diagnosisDate = daysPassed(7); - final var procedureDate = daysPassed(1); - - doAnswer(invocationOnMock -> List.of()) - .when(systemtherapieService).ecogStatus(any(Patient.class)); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setStartDate(procedureDate); - procedure.setEditState(ProcedureEditStateType.COMPLETED); - procedure.setPatientId(1); - procedure.setPatient(patient); - procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); - - verify(onkostarApi, times(0)).getProceduresForDiseaseByForm(anyInt(), anyString()); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void shouldNotIncludeEcogStatusBeforeDiagnosisDate() throws Exception { - final var diagnosisDate = daysPassed(7); - final var ecogDate = daysPassed(28); - final var procedureDate = daysPassed(1); - - doAnswer(invocationOnMock -> List.of(new EcogStatusWithDate(ecogDate, "0"))) - .when(systemtherapieService).ecogStatus(any(Patient.class)); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setStartDate(procedureDate); - procedure.setEditState(ProcedureEditStateType.COMPLETED); - procedure.setPatientId(1); - procedure.setPatient(patient); - procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); - - verify(onkostarApi, times(0)).getProceduresForDiseaseByForm(anyInt(), anyString()); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void shouldRequestEcogFromStrahlentherapieAndSystemtherapie() { - final var diagnosisDate = daysPassed(7); - final var procedureDate = daysPassed(1); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var procedure = new Procedure(onkostarApi); - procedure.setId(1000); - procedure.setStartDate(procedureDate); - procedure.setEditState(ProcedureEditStateType.COMPLETED); - procedure.setPatientId(1); - procedure.setPatient(patient); - procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); - - verify(strahlentherapieService, times(1)).ecogStatus(any()); - verify(systemtherapieService, times(1)).ecogStatus(any()); - } - + private IOnkostarApi onkostarApi; + + private StrahlentherapieService strahlentherapieService; + + private SystemtherapieService systemtherapieService; + + private TherapieMitEcogAnalyzer therapieMitEcogAnalyzer; + + private Disease dummyDisease(int id, Date diagnosisDate) { + var disease = new Disease(onkostarApi); + disease.setId(id); + disease.setDiagnosisDate(diagnosisDate); + return disease; + } + + private Date daysPassed(int days) { + return Date.from(Instant.now().minus(days, ChronoUnit.DAYS)); + } + + @BeforeEach + void setUp( + @Mock IOnkostarApi onkostarApi, + @Mock StrahlentherapieService strahlentherapieService, + @Mock SystemtherapieService systemtherapieService) { + this.onkostarApi = onkostarApi; + this.strahlentherapieService = strahlentherapieService; + this.systemtherapieService = systemtherapieService; + this.therapieMitEcogAnalyzer = + new TherapieMitEcogAnalyzer(onkostarApi, strahlentherapieService, systemtherapieService); + } + + @Test + void shouldInsertNewEcogStatus() throws Exception { + final var diagnosisDate = daysPassed(7); + final var ecogDate = daysPassed(1); + final var procedureDate = daysPassed(1); + + doAnswer(invocationOnMock -> List.of(new EcogStatusWithDate(ecogDate, "0"))) + .when(systemtherapieService) + .ecogStatus(any(Patient.class)); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setStartDate(procedureDate); + procedure.setEditState(ProcedureEditStateType.COMPLETED); + procedure.setPatientId(1); + procedure.setPatient(patient); + procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + doAnswer(invocationOnMock -> List.of(dummyDisease(42, diagnosisDate))) + .when(this.onkostarApi) + .getDiseasesByPatientId(anyInt()); + + doAnswer(invocationOnMock -> List.of(procedure)) + .when(onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); + + var idCaptor = ArgumentCaptor.forClass(Integer.class); + var formNameCaptor = ArgumentCaptor.forClass(String.class); + verify(onkostarApi, times(1)) + .getProceduresForDiseaseByForm(idCaptor.capture(), formNameCaptor.capture()); + assertThat(idCaptor.getValue()).isEqualTo(42); + assertThat(formNameCaptor.getValue()).isEqualTo("DNPM Klinik/Anamnese"); + + verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void shouldNotModifyEcogStatusIfNoCompletedSystemTherapy() throws Exception { + final var diagnosisDate = daysPassed(7); + final var procedureDate = daysPassed(1); + + doAnswer(invocationOnMock -> List.of()) + .when(systemtherapieService) + .ecogStatus(any(Patient.class)); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setStartDate(procedureDate); + procedure.setEditState(ProcedureEditStateType.COMPLETED); + procedure.setPatientId(1); + procedure.setPatient(patient); + procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); + + verify(onkostarApi, times(0)).getProceduresForDiseaseByForm(anyInt(), anyString()); + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void shouldNotIncludeEcogStatusBeforeDiagnosisDate() throws Exception { + final var diagnosisDate = daysPassed(7); + final var ecogDate = daysPassed(28); + final var procedureDate = daysPassed(1); + + doAnswer(invocationOnMock -> List.of(new EcogStatusWithDate(ecogDate, "0"))) + .when(systemtherapieService) + .ecogStatus(any(Patient.class)); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setStartDate(procedureDate); + procedure.setEditState(ProcedureEditStateType.COMPLETED); + procedure.setPatientId(1); + procedure.setPatient(patient); + procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); + + verify(onkostarApi, times(0)).getProceduresForDiseaseByForm(anyInt(), anyString()); + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void shouldRequestEcogFromStrahlentherapieAndSystemtherapie() { + final var diagnosisDate = daysPassed(7); + final var procedureDate = daysPassed(1); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var procedure = new Procedure(onkostarApi); + procedure.setId(1000); + procedure.setStartDate(procedureDate); + procedure.setEditState(ProcedureEditStateType.COMPLETED); + procedure.setPatientId(1); + procedure.setPatient(patient); + procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + therapieMitEcogAnalyzer.analyze(procedure, dummyDisease(10, diagnosisDate)); + + verify(strahlentherapieService, times(1)).ecogStatus(any()); + verify(systemtherapieService, times(1)).ecogStatus(any()); + } } diff --git a/src/test/java/dev/dnpm/oshelper/analyzer/TherapieplanAnalyzerTest.java b/src/test/java/dev/dnpm/oshelper/analyzer/TherapieplanAnalyzerTest.java index 0ee1ef8..dc75e51 100644 --- a/src/test/java/dev/dnpm/oshelper/analyzer/TherapieplanAnalyzerTest.java +++ b/src/test/java/dev/dnpm/oshelper/analyzer/TherapieplanAnalyzerTest.java @@ -19,6 +19,8 @@ package dev.dnpm.oshelper.analyzer; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Procedure; import dev.dnpm.oshelper.services.FormService; @@ -30,35 +32,29 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class TherapieplanAnalyzerTest { - @Mock - private IOnkostarApi onkostarApi; - - @Mock - private FormService formService; + @Mock private IOnkostarApi onkostarApi; - @Mock - private TherapieplanServiceFactory therapieplanServiceFactory; + @Mock private FormService formService; - private TherapieplanAnalyzer therapieplanAnalyzer; + @Mock private TherapieplanServiceFactory therapieplanServiceFactory; - @BeforeEach - void setUp() { - this.therapieplanAnalyzer = new TherapieplanAnalyzer(therapieplanServiceFactory); - } + private TherapieplanAnalyzer therapieplanAnalyzer; - @Test - void shouldRunServiceMethodsOnAnalyzeCalled() { - when(this.therapieplanServiceFactory.currentUsableInstance()) - .thenReturn(new DefaultTherapieplanService(onkostarApi, formService)); + @BeforeEach + void setUp() { + this.therapieplanAnalyzer = new TherapieplanAnalyzer(therapieplanServiceFactory); + } - this.therapieplanAnalyzer.analyze(new Procedure(onkostarApi), null); + @Test + void shouldRunServiceMethodsOnAnalyzeCalled() { + when(this.therapieplanServiceFactory.currentUsableInstance()) + .thenReturn(new DefaultTherapieplanService(onkostarApi, formService)); - verify(this.therapieplanServiceFactory, times(1)).currentUsableInstance(); - } + this.therapieplanAnalyzer.analyze(new Procedure(onkostarApi), null); + verify(this.therapieplanServiceFactory, times(1)).currentUsableInstance(); + } } diff --git a/src/test/java/dev/dnpm/oshelper/atc/AgentCodeServiceTest.java b/src/test/java/dev/dnpm/oshelper/atc/AgentCodeServiceTest.java index 7516b08..95030b5 100644 --- a/src/test/java/dev/dnpm/oshelper/atc/AgentCodeServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/atc/AgentCodeServiceTest.java @@ -19,65 +19,61 @@ package dev.dnpm.oshelper.atc; -import dev.dnpm.oshelper.atc.services.AgentCodeService; -import org.junit.jupiter.api.Test; +import static org.assertj.core.api.Assertions.assertThat; +import dev.dnpm.oshelper.atc.services.AgentCodeService; import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; +import org.junit.jupiter.api.Test; class AgentCodeServiceTest { - @Test - void shouldReturnLatestAvailableAgentCodeVersion() { - var testAgentCodes = List.of( - new AtcCode("A01AD05", "Acetylsalicylsäure"), - new AtcCode("A01AD05", "Acetylsalicylsäure", "2025"), - new AtcCode("A01AD05", "Acetylsalicylsäure", "2026"), - new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), - new UnregisteredCode("", "Acetylsalicylsäure") - ); - - var actual = AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byNameAndCode); + @Test + void shouldReturnLatestAvailableAgentCodeVersion() { + var testAgentCodes = + List.of( + new AtcCode("A01AD05", "Acetylsalicylsäure"), + new AtcCode("A01AD05", "Acetylsalicylsäure", "2025"), + new AtcCode("A01AD05", "Acetylsalicylsäure", "2026"), + new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), + new UnregisteredCode("", "Acetylsalicylsäure")); - assertThat(actual).containsAll( - List.of( - new AtcCode("A01AD05", "Acetylsalicylsäure", "2026"), - new UnregisteredCode("", "Acetylsalicylsäure") - ) - ); - } + var actual = + AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byNameAndCode); - @Test - void shouldReturnLatestAvailableAgentCodeVersionByNameOnly() { - var testAgentCodes = List.of( - new AtcCode("A01AD05", "Acetylsalicylsäure"), - new AtcCode("A01AD05", "Acetylsalicylsäure", "2025"), + assertThat(actual) + .containsAll( + List.of( new AtcCode("A01AD05", "Acetylsalicylsäure", "2026"), - new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), - new UnregisteredCode("", "Acetylsalicylsäure") - ); + new UnregisteredCode("", "Acetylsalicylsäure"))); + } - var actual = AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byCodeOnly); + @Test + void shouldReturnLatestAvailableAgentCodeVersionByNameOnly() { + var testAgentCodes = + List.of( + new AtcCode("A01AD05", "Acetylsalicylsäure"), + new AtcCode("A01AD05", "Acetylsalicylsäure", "2025"), + new AtcCode("A01AD05", "Acetylsalicylsäure", "2026"), + new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), + new UnregisteredCode("", "Acetylsalicylsäure")); - assertThat(actual).containsExactly( - new AtcCode("A01AD05", "Acetylsalicylsäure", "2026") - ); - } + var actual = + AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byCodeOnly); - @Test - void shouldReturnLatestAvailableAgentCodeWithoutVersionVersionByNameOnly() { - var testAgentCodes = List.of( - new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), - new AtcCode("A01AD05", "Acetylsalicylsäure"), - new UnregisteredCode("", "Acetylsalicylsäure") - ); + assertThat(actual).containsExactly(new AtcCode("A01AD05", "Acetylsalicylsäure", "2026")); + } - var actual = AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byCodeOnly); + @Test + void shouldReturnLatestAvailableAgentCodeWithoutVersionVersionByNameOnly() { + var testAgentCodes = + List.of( + new UnregisteredCode("A01AD05", "Acetylsalicylsäure"), + new AtcCode("A01AD05", "Acetylsalicylsäure"), + new UnregisteredCode("", "Acetylsalicylsäure")); - assertThat(actual).containsExactly( - new AtcCode("A01AD05", "Acetylsalicylsäure") - ); - } + var actual = + AgentCodeService.latestAgentCodeVersions(testAgentCodes, AgentCodeService.byCodeOnly); + assertThat(actual).containsExactly(new AtcCode("A01AD05", "Acetylsalicylsäure")); + } } diff --git a/src/test/java/dev/dnpm/oshelper/atc/AtcCodeTest.java b/src/test/java/dev/dnpm/oshelper/atc/AtcCodeTest.java index 7e3240d..35fd34e 100644 --- a/src/test/java/dev/dnpm/oshelper/atc/AtcCodeTest.java +++ b/src/test/java/dev/dnpm/oshelper/atc/AtcCodeTest.java @@ -19,29 +19,28 @@ package dev.dnpm.oshelper.atc; -import org.junit.jupiter.api.Test; - import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; -class AtcCodeTest { +import org.junit.jupiter.api.Test; - @Test - void testShouldDetectAtcCodeScheme() { - assertTrue(AtcCode.isAtcCode("L01")); - assertTrue(AtcCode.isAtcCode("L01A")); - assertTrue(AtcCode.isAtcCode("L01AA")); - assertTrue(AtcCode.isAtcCode("L01AA01")); - } +class AtcCodeTest { - @Test - void testShouldDetectInvalidAtcCodeScheme() { - assertFalse(AtcCode.isAtcCode(null)); - assertFalse(AtcCode.isAtcCode(" ")); - assertFalse(AtcCode.isAtcCode("irgendwas")); - assertFalse(AtcCode.isAtcCode("L00AA")); - assertFalse(AtcCode.isAtcCode("Z01AA")); - assertFalse(AtcCode.isAtcCode("L01AA0")); - } + @Test + void testShouldDetectAtcCodeScheme() { + assertTrue(AtcCode.isAtcCode("L01")); + assertTrue(AtcCode.isAtcCode("L01A")); + assertTrue(AtcCode.isAtcCode("L01AA")); + assertTrue(AtcCode.isAtcCode("L01AA01")); + } + @Test + void testShouldDetectInvalidAtcCodeScheme() { + assertFalse(AtcCode.isAtcCode(null)); + assertFalse(AtcCode.isAtcCode(" ")); + assertFalse(AtcCode.isAtcCode("irgendwas")); + assertFalse(AtcCode.isAtcCode("L00AA")); + assertFalse(AtcCode.isAtcCode("Z01AA")); + assertFalse(AtcCode.isAtcCode("L01AA0")); + } } diff --git a/src/test/java/dev/dnpm/oshelper/atc/CsvAgentCodeServiceTest.java b/src/test/java/dev/dnpm/oshelper/atc/CsvAgentCodeServiceTest.java index 2735e01..82fd837 100644 --- a/src/test/java/dev/dnpm/oshelper/atc/CsvAgentCodeServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/atc/CsvAgentCodeServiceTest.java @@ -19,22 +19,21 @@ package dev.dnpm.oshelper.atc; +import static org.assertj.core.api.Assertions.assertThat; + import dev.dnpm.oshelper.atc.services.AgentCodeService; import dev.dnpm.oshelper.atc.services.CsvAgentCodeService; import org.junit.jupiter.api.Test; -import static org.assertj.core.api.Assertions.assertThat; - class CsvAgentCodeServiceTest { - AgentCodeService agentCodeService = new CsvAgentCodeService(); - - @Test - void shouldReturnAtcCodeFromEmbeddedResource() { - var actual = agentCodeService.findAgentCodes("Cisplatin", 10); + AgentCodeService agentCodeService = new CsvAgentCodeService(); - assertThat(actual).hasSize(1); - assertThat(actual.get(0).getCode()).isEqualTo("L01XA01"); - } + @Test + void shouldReturnAtcCodeFromEmbeddedResource() { + var actual = agentCodeService.findAgentCodes("Cisplatin", 10); + assertThat(actual).hasSize(1); + assertThat(actual.get(0).getCode()).isEqualTo("L01XA01"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/config/PluginConfigurationTest.java b/src/test/java/dev/dnpm/oshelper/config/PluginConfigurationTest.java index 6b80968..42583ca 100644 --- a/src/test/java/dev/dnpm/oshelper/config/PluginConfigurationTest.java +++ b/src/test/java/dev/dnpm/oshelper/config/PluginConfigurationTest.java @@ -19,47 +19,45 @@ package dev.dnpm.oshelper.config; +import static org.assertj.core.api.Assertions.assertThat; + +import de.itc.onkostar.api.IOnkostarApi; import dev.dnpm.oshelper.services.FormService; import dev.dnpm.oshelper.services.SettingsService; -import dev.dnpm.oshelper.services.therapieplan.TherapieplanServiceFactory; import dev.dnpm.oshelper.services.consent.ConsentManagerServiceFactory; -import de.itc.onkostar.api.IOnkostarApi; +import dev.dnpm.oshelper.services.therapieplan.TherapieplanServiceFactory; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; - @ExtendWith(MockitoExtension.class) class PluginConfigurationTest { - @Mock - private IOnkostarApi onkostarApi; + @Mock private IOnkostarApi onkostarApi; - @Mock - private SettingsService settingsService; + @Mock private SettingsService settingsService; - @Mock - private FormService formService; + @Mock private FormService formService; - private PluginConfiguration configuration; + private PluginConfiguration configuration; - @BeforeEach - void setup() { - this.configuration = new PluginConfiguration(); - } + @BeforeEach + void setup() { + this.configuration = new PluginConfiguration(); + } - @Test - void testShouldReturnConsentManagerServiceFactory() { - var actual = this.configuration.consentManagerServiceFactory(onkostarApi); - assertThat(actual).isInstanceOf(ConsentManagerServiceFactory.class); - } + @Test + void testShouldReturnConsentManagerServiceFactory() { + var actual = this.configuration.consentManagerServiceFactory(onkostarApi); + assertThat(actual).isInstanceOf(ConsentManagerServiceFactory.class); + } - @Test - void testShouldReturnTherapieplanServiceFactory() { - var actual = this.configuration.therapieplanServiceFactory(onkostarApi, settingsService, formService); - assertThat(actual).isInstanceOf(TherapieplanServiceFactory.class); - } + @Test + void testShouldReturnTherapieplanServiceFactory() { + var actual = + this.configuration.therapieplanServiceFactory(onkostarApi, settingsService, formService); + assertThat(actual).isInstanceOf(TherapieplanServiceFactory.class); + } } diff --git a/src/test/java/dev/dnpm/oshelper/dto/VariantTest.java b/src/test/java/dev/dnpm/oshelper/dto/VariantTest.java index aa39ba3..9ab2b3d 100644 --- a/src/test/java/dev/dnpm/oshelper/dto/VariantTest.java +++ b/src/test/java/dev/dnpm/oshelper/dto/VariantTest.java @@ -19,104 +19,103 @@ package dev.dnpm.oshelper.dto; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; import org.junit.jupiter.api.Test; -import static org.assertj.core.api.Assertions.assertThat; - public class VariantTest { - @Test - void testShouldMapVariantFromProcedureForSimpleVariant() { - var procedure = new Procedure(null); - procedure.setId(12345); - procedure.setFormName("OS.Molekulargenetische Untersuchung"); - - procedure.setValue("Ergebnis", new Item("Ergebnis", "P")); - procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); - procedure.setValue("ExonInt", new Item("ExonInt", 123)); - procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - - var actual = Variant.fromProcedure(procedure); - - assertThat(actual).isPresent(); - assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Einfache Variante (Mutation)"); - assertThat(actual.get().getGen()).isEqualTo("BRAF"); - assertThat(actual.get().getExon()).isEqualTo("123"); - assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); - } - - @Test - void testShouldMapVariantFromProcedureForCopyNumberVariation() { - var procedure = new Procedure(null); - procedure.setId(12345); - procedure.setFormName("OS.Molekulargenetische Untersuchung"); - - procedure.setValue("Ergebnis", new Item("Ergebnis", "CNV")); - procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); - procedure.setValue("ExonInt", new Item("ExonInt", 123)); - procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - - var actual = Variant.fromProcedure(procedure); - - assertThat(actual).isPresent(); - assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Copy Number Variation (CNV)"); - assertThat(actual.get().getGen()).isEqualTo("BRAF"); - assertThat(actual.get().getExon()).isEqualTo("123"); - assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); - } - - @Test - void testShouldMapVariantFromProcedureForFusion() { - var procedure = new Procedure(null); - procedure.setId(12345); - procedure.setFormName("OS.Molekulargenetische Untersuchung"); - - procedure.setValue("Ergebnis", new Item("Ergebnis", "F")); - procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); - procedure.setValue("ExonInt", new Item("ExonInt", 123)); - procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - - var actual = Variant.fromProcedure(procedure); - - assertThat(actual).isPresent(); - assertThat(actual.get().getId()).isEqualTo(12345); - assertThat(actual.get().getErgebnis()).isEqualTo("Fusion (Translokation Inversion Insertion)"); - assertThat(actual.get().getGen()).isEqualTo("BRAF"); - assertThat(actual.get().getExon()).isEqualTo("123"); - assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); - } - - @Test - void testShouldNotMapVariantFromProcedureForUnknownVariant() { - var procedure = new Procedure(null); - procedure.setId(12345); - procedure.setFormName("OS.Molekulargenetische Untersuchung"); - - procedure.setValue("Ergebnis", new Item("Ergebnis", "X")); - procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); - procedure.setValue("ExonInt", new Item("ExonInt", 123)); - procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - - var actual = Variant.fromProcedure(procedure); - - assertThat(actual).isEmpty(); - } - - @Test - void testShouldNotMapVariantFromUnknownProcedureForm() { - var procedure = new Procedure(null); - procedure.setId(12345); - procedure.setFormName("ABC.Irgendwas"); - - procedure.setValue("Testfeld", new Item("Testfeld", "T")); - - var actual = Variant.fromProcedure(procedure); - - assertThat(actual).isEmpty(); - } - + @Test + void testShouldMapVariantFromProcedureForSimpleVariant() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "P")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Einfache Variante (Mutation)"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldMapVariantFromProcedureForCopyNumberVariation() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "CNV")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Copy Number Variation (CNV)"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldMapVariantFromProcedureForFusion() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "F")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isPresent(); + assertThat(actual.get().getId()).isEqualTo(12345); + assertThat(actual.get().getErgebnis()).isEqualTo("Fusion (Translokation Inversion Insertion)"); + assertThat(actual.get().getGen()).isEqualTo("BRAF"); + assertThat(actual.get().getExon()).isEqualTo("123"); + assertThat(actual.get().getPathogenitaetsklasse()).isEqualTo("2"); + } + + @Test + void testShouldNotMapVariantFromProcedureForUnknownVariant() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("OS.Molekulargenetische Untersuchung"); + + procedure.setValue("Ergebnis", new Item("Ergebnis", "X")); + procedure.setValue("Untersucht", new Item("Untersucht", "BRAF")); + procedure.setValue("ExonInt", new Item("ExonInt", 123)); + procedure.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isEmpty(); + } + + @Test + void testShouldNotMapVariantFromUnknownProcedureForm() { + var procedure = new Procedure(null); + procedure.setId(12345); + procedure.setFormName("ABC.Irgendwas"); + + procedure.setValue("Testfeld", new Item("Testfeld", "T")); + + var actual = Variant.fromProcedure(procedure); + + assertThat(actual).isEmpty(); + } } diff --git a/src/test/java/dev/dnpm/oshelper/security/DelegatingDataBasedPermissionEvaluatorTest.java b/src/test/java/dev/dnpm/oshelper/security/DelegatingDataBasedPermissionEvaluatorTest.java index 0f615ec..a305bb2 100644 --- a/src/test/java/dev/dnpm/oshelper/security/DelegatingDataBasedPermissionEvaluatorTest.java +++ b/src/test/java/dev/dnpm/oshelper/security/DelegatingDataBasedPermissionEvaluatorTest.java @@ -19,8 +19,14 @@ package dev.dnpm.oshelper.security; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.when; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Patient; +import java.util.Collection; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -29,113 +35,124 @@ import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.security.core.Authentication; import org.springframework.security.core.GrantedAuthority; -import java.util.Collection; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.*; -import static org.mockito.Mockito.when; - @ExtendWith(MockitoExtension.class) class DelegatingDataBasedPermissionEvaluatorTest { - private IOnkostarApi onkostarApi; - - private PersonPoolBasedPermissionEvaluator personPoolBasedPermissionEvaluator; - - private FormBasedPermissionEvaluator formBasedPermissionEvaluator; - - private DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock PersonPoolBasedPermissionEvaluator personPoolBasedPermissionEvaluator, - @Mock FormBasedPermissionEvaluator formBasedPermissionEvaluator - ) { - this.onkostarApi = onkostarApi; - this.personPoolBasedPermissionEvaluator = personPoolBasedPermissionEvaluator; - this.formBasedPermissionEvaluator = formBasedPermissionEvaluator; - - this.delegatingDataBasedPermissionEvaluator = new DelegatingDataBasedPermissionEvaluator( - List.of(personPoolBasedPermissionEvaluator, formBasedPermissionEvaluator) - ); - } - - @Test - void testShouldGrantPermissionIfAllDelegatedPermissionEvaluatorsGrantsAccessByObject() { - when(personPoolBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))).thenReturn(true); - when(formBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))).thenReturn(true); - - var actual = delegatingDataBasedPermissionEvaluator.hasPermission(new DummyAuthentication(), new Patient(this.onkostarApi), PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldGrantPermissionIfAllDelegatedPermissionEvaluatorsGrantsAccessByIdAndType() { - when(personPoolBasedPermissionEvaluator.hasPermission(any(), anyInt(), anyString(), any(PermissionType.class))).thenReturn(true); - when(formBasedPermissionEvaluator.hasPermission(any(), anyInt(), anyString(), any(PermissionType.class))).thenReturn(true); - - var actual = delegatingDataBasedPermissionEvaluator.hasPermission(new DummyAuthentication(), 123, "Patient", PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldDenyPermissionIfAtLeastOneDelegatedPermissionEvaluatorsDeniesAccessByObject() { - when(personPoolBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))).thenReturn(true); - when(formBasedPermissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))).thenReturn(false); - - var actual = delegatingDataBasedPermissionEvaluator.hasPermission(new DummyAuthentication(), new Patient(this.onkostarApi), PermissionType.READ); - - assertThat(actual).isFalse(); - } - - @Test - void testShouldDenyPermissionIfAtLeastOneDelegatedPermissionEvaluatorsDeniesAccessByIdAndType() { - when(personPoolBasedPermissionEvaluator.hasPermission(any(), anyInt(), anyString(), any(PermissionType.class))).thenReturn(false); - - var actual = delegatingDataBasedPermissionEvaluator.hasPermission(new DummyAuthentication(), 123, "Patient", PermissionType.READ); - - assertThat(actual).isFalse(); - } - + private IOnkostarApi onkostarApi; + + private PersonPoolBasedPermissionEvaluator personPoolBasedPermissionEvaluator; + + private FormBasedPermissionEvaluator formBasedPermissionEvaluator; + + private DelegatingDataBasedPermissionEvaluator delegatingDataBasedPermissionEvaluator; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock PersonPoolBasedPermissionEvaluator personPoolBasedPermissionEvaluator, + @Mock FormBasedPermissionEvaluator formBasedPermissionEvaluator) { + this.onkostarApi = onkostarApi; + this.personPoolBasedPermissionEvaluator = personPoolBasedPermissionEvaluator; + this.formBasedPermissionEvaluator = formBasedPermissionEvaluator; + + this.delegatingDataBasedPermissionEvaluator = + new DelegatingDataBasedPermissionEvaluator( + List.of(personPoolBasedPermissionEvaluator, formBasedPermissionEvaluator)); + } + + @Test + void testShouldGrantPermissionIfAllDelegatedPermissionEvaluatorsGrantsAccessByObject() { + when(personPoolBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); + when(formBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); + + var actual = + delegatingDataBasedPermissionEvaluator.hasPermission( + new DummyAuthentication(), new Patient(this.onkostarApi), PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldGrantPermissionIfAllDelegatedPermissionEvaluatorsGrantsAccessByIdAndType() { + when(personPoolBasedPermissionEvaluator.hasPermission( + any(), anyInt(), anyString(), any(PermissionType.class))) + .thenReturn(true); + when(formBasedPermissionEvaluator.hasPermission( + any(), anyInt(), anyString(), any(PermissionType.class))) + .thenReturn(true); + + var actual = + delegatingDataBasedPermissionEvaluator.hasPermission( + new DummyAuthentication(), 123, "Patient", PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldDenyPermissionIfAtLeastOneDelegatedPermissionEvaluatorsDeniesAccessByObject() { + when(personPoolBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); + when(formBasedPermissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(false); + + var actual = + delegatingDataBasedPermissionEvaluator.hasPermission( + new DummyAuthentication(), new Patient(this.onkostarApi), PermissionType.READ); + + assertThat(actual).isFalse(); + } + + @Test + void testShouldDenyPermissionIfAtLeastOneDelegatedPermissionEvaluatorsDeniesAccessByIdAndType() { + when(personPoolBasedPermissionEvaluator.hasPermission( + any(), anyInt(), anyString(), any(PermissionType.class))) + .thenReturn(false); + + var actual = + delegatingDataBasedPermissionEvaluator.hasPermission( + new DummyAuthentication(), 123, "Patient", PermissionType.READ); + + assertThat(actual).isFalse(); + } } class DummyAuthentication implements Authentication { - @Override - public String getName() { - return "dummy"; - } - - @Override - public Collection getAuthorities() { - return null; - } - - @Override - public Object getCredentials() { - return null; - } - - @Override - public Object getDetails() { - return null; - } - - @Override - public Object getPrincipal() { - return null; - } - - @Override - public boolean isAuthenticated() { - return false; - } - - @Override - public void setAuthenticated(boolean b) throws IllegalArgumentException { - - } -} \ No newline at end of file + @Override + public String getName() { + return "dummy"; + } + + @Override + public Collection getAuthorities() { + return null; + } + + @Override + public Object getCredentials() { + return null; + } + + @Override + public Object getDetails() { + return null; + } + + @Override + public Object getPrincipal() { + return null; + } + + @Override + public boolean isAuthenticated() { + return false; + } + + @Override + public void setAuthenticated(boolean b) throws IllegalArgumentException {} +} diff --git a/src/test/java/dev/dnpm/oshelper/security/FormBasedPermissionEvaluatorTest.java b/src/test/java/dev/dnpm/oshelper/security/FormBasedPermissionEvaluatorTest.java index 6c363d4..60e896a 100644 --- a/src/test/java/dev/dnpm/oshelper/security/FormBasedPermissionEvaluatorTest.java +++ b/src/test/java/dev/dnpm/oshelper/security/FormBasedPermissionEvaluatorTest.java @@ -19,9 +19,16 @@ package dev.dnpm.oshelper.security; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.when; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Patient; import de.itc.onkostar.api.Procedure; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -29,103 +36,123 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.security.core.Authentication; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.when; - @ExtendWith(MockitoExtension.class) class FormBasedPermissionEvaluatorTest { - private IOnkostarApi onkostarApi; - - private Authentication dummyAuthentication; - - private SecurityService securityService; - - private FormBasedPermissionEvaluator permissionEvaluator; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock SecurityService securityService, - @Mock DummyAuthentication dummyAuthentication - ) { - this.onkostarApi = onkostarApi; - this.dummyAuthentication = dummyAuthentication; - this.securityService = securityService; - - this.permissionEvaluator = new FormBasedPermissionEvaluator( - onkostarApi, securityService - ); - } - - @Test - void testShouldGrantPermissionByProcedure() { - when(securityService.getFormNamesForPermission(any(Authentication.class), any(PermissionType.class))).thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form2"); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - assertThat(actual).isTrue(); - } - - @Test - void testShouldGrantPermissionByProcedureId() { - when(securityService.getFormNamesForPermission(any(Authentication.class), any(PermissionType.class))).thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); - - doAnswer(invocationOnMock -> { - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form2"); - return object; - }).when(onkostarApi).getProcedure(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, PersonPoolBasedPermissionEvaluator.PROCEDURE, PermissionType.READ); - assertThat(actual).isTrue(); - } - - @Test - void testShouldDenyPermissionByProcedure() { - when(securityService.getFormNamesForPermission(any(Authentication.class), any(PermissionType.class))).thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - assertThat(actual).isFalse(); - } - - @Test - void testShouldDenyPermissionByProcedureId() { - when(securityService.getFormNamesForPermission(any(Authentication.class), any(PermissionType.class))).thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); - - doAnswer(invocationOnMock -> { - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - return object; - }).when(onkostarApi).getProcedure(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, PersonPoolBasedPermissionEvaluator.PROCEDURE, PermissionType.READ); - assertThat(actual).isFalse(); - } - - @Test - void testShouldVoteForPermissionToPatient() { - var object = new Patient(onkostarApi); - object.setPersonPoolCode("Pool1"); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - assertThat(actual).isTrue(); - } - - @Test - void testShouldVoteForPermissionToIdOfTypeProcedure() { - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, FormBasedPermissionEvaluator.PATIENT, PermissionType.READ); - assertThat(actual).isTrue(); - } - + private IOnkostarApi onkostarApi; + + private Authentication dummyAuthentication; + + private SecurityService securityService; + + private FormBasedPermissionEvaluator permissionEvaluator; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock SecurityService securityService, + @Mock DummyAuthentication dummyAuthentication) { + this.onkostarApi = onkostarApi; + this.dummyAuthentication = dummyAuthentication; + this.securityService = securityService; + + this.permissionEvaluator = new FormBasedPermissionEvaluator(onkostarApi, securityService); + } + + @Test + void testShouldGrantPermissionByProcedure() { + when(securityService.getFormNamesForPermission( + any(Authentication.class), any(PermissionType.class))) + .thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form2"); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + assertThat(actual).isTrue(); + } + + @Test + void testShouldGrantPermissionByProcedureId() { + when(securityService.getFormNamesForPermission( + any(Authentication.class), any(PermissionType.class))) + .thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); + + doAnswer( + invocationOnMock -> { + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form2"); + return object; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + PersonPoolBasedPermissionEvaluator.PROCEDURE, + PermissionType.READ); + assertThat(actual).isTrue(); + } + + @Test + void testShouldDenyPermissionByProcedure() { + when(securityService.getFormNamesForPermission( + any(Authentication.class), any(PermissionType.class))) + .thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + assertThat(actual).isFalse(); + } + + @Test + void testShouldDenyPermissionByProcedureId() { + when(securityService.getFormNamesForPermission( + any(Authentication.class), any(PermissionType.class))) + .thenReturn(List.of("OS.Form2", "OS.Form3", "OS.Form5")); + + doAnswer( + invocationOnMock -> { + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + return object; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + PersonPoolBasedPermissionEvaluator.PROCEDURE, + PermissionType.READ); + assertThat(actual).isFalse(); + } + + @Test + void testShouldVoteForPermissionToPatient() { + var object = new Patient(onkostarApi); + object.setPersonPoolCode("Pool1"); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + assertThat(actual).isTrue(); + } + + @Test + void testShouldVoteForPermissionToIdOfTypeProcedure() { + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + FormBasedPermissionEvaluator.PATIENT, + PermissionType.READ); + assertThat(actual).isTrue(); + } } diff --git a/src/test/java/dev/dnpm/oshelper/security/FormBasedSecurityAspectsTest.java b/src/test/java/dev/dnpm/oshelper/security/FormBasedSecurityAspectsTest.java index 54d7873..a7660b6 100644 --- a/src/test/java/dev/dnpm/oshelper/security/FormBasedSecurityAspectsTest.java +++ b/src/test/java/dev/dnpm/oshelper/security/FormBasedSecurityAspectsTest.java @@ -19,6 +19,10 @@ package dev.dnpm.oshelper.security; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Patient; import de.itc.onkostar.api.Procedure; @@ -29,122 +33,118 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.aop.aspectj.annotation.AspectJProxyFactory; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class FormBasedSecurityAspectsTest { - private DummyClass dummyClass; - - private IOnkostarApi onkostarApi; - - private FormBasedPermissionEvaluator permissionEvaluator; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock FormBasedPermissionEvaluator permissionEvaluator - ) { - this.onkostarApi = onkostarApi; - this.permissionEvaluator = permissionEvaluator; - - // Create proxied instance of DummyClass as done within Onkostar using Spring AOP - var dummyClass = new DummyClass(onkostarApi); - AspectJProxyFactory factory = new AspectJProxyFactory(dummyClass); - FormBasedSecurityAspects securityAspects = new FormBasedSecurityAspects(this.permissionEvaluator); - factory.addAspect(securityAspects); - this.dummyClass = factory.getProxy(); + private DummyClass dummyClass; + + private IOnkostarApi onkostarApi; + + private FormBasedPermissionEvaluator permissionEvaluator; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, @Mock FormBasedPermissionEvaluator permissionEvaluator) { + this.onkostarApi = onkostarApi; + this.permissionEvaluator = permissionEvaluator; + + // Create proxied instance of DummyClass as done within Onkostar using Spring AOP + var dummyClass = new DummyClass(onkostarApi); + AspectJProxyFactory factory = new AspectJProxyFactory(dummyClass); + FormBasedSecurityAspects securityAspects = + new FormBasedSecurityAspects(this.permissionEvaluator); + factory.addAspect(securityAspects); + this.dummyClass = factory.getProxy(); + } + + @Test + void testShouldAllowSecuredMethodCallWithPatientParam() { + this.dummyClass.methodWithPatientParam(new Patient(onkostarApi)); + verify(onkostarApi, times(1)).savePatient(any(Patient.class)); + } + + @Test + void testShouldPreventSecuredMethodCallWithProcedureParam() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows( + Exception.class, + () -> this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi))); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithProcedureParam() throws Exception { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(true); + + this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)); + + verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void testShouldAllowSecuredMethodCallWithPatientReturnValue() { + var actual = this.dummyClass.methodWithPatientReturnValue(1); + assertThat(actual).isNotNull(); + } + + @Test + void testShouldPreventSecuredMethodCallWithProcedureReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows(Exception.class, () -> this.dummyClass.methodWithProcedureReturnValue(1)); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithProcedureReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(true); + + var actual = this.dummyClass.methodWithProcedureReturnValue(1); + + assertThat(actual).isNotNull(); + } + + private static class DummyClass { + + private final IOnkostarApi onkostarApi; + + DummyClass(final IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; } - @Test - void testShouldAllowSecuredMethodCallWithPatientParam() { - this.dummyClass.methodWithPatientParam(new Patient(onkostarApi)); - verify(onkostarApi, times(1)).savePatient(any(Patient.class)); + @FormSecured + public void methodWithPatientParam(Patient patient) { + this.onkostarApi.savePatient(patient); } - @Test - void testShouldPreventSecuredMethodCallWithProcedureParam() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + @FormSecured + public void methodWithProcedureParam(Procedure procedure) throws Exception { + this.onkostarApi.saveProcedure(procedure, false); } - @Test - void testShouldAllowSecuredMethodCallWithProcedureParam() throws Exception { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(true); - - this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)); - - verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void testShouldAllowSecuredMethodCallWithPatientReturnValue() { - var actual = this.dummyClass.methodWithPatientReturnValue(1); - assertThat(actual).isNotNull(); - } - - @Test - void testShouldPreventSecuredMethodCallWithProcedureReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithProcedureReturnValue(1) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); - } - - @Test - void testShouldAllowSecuredMethodCallWithProcedureReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(true); - - var actual = this.dummyClass.methodWithProcedureReturnValue(1); - - assertThat(actual).isNotNull(); + @FormSecuredResult + public Patient methodWithPatientReturnValue(int id) { + var patient = new Patient(this.onkostarApi); + patient.setId(id); + return patient; } - private static class DummyClass { - - private final IOnkostarApi onkostarApi; - - DummyClass(final IOnkostarApi onkostarApi) { - this.onkostarApi = onkostarApi; - } - - @FormSecured - public void methodWithPatientParam(Patient patient) { - this.onkostarApi.savePatient(patient); - } - - @FormSecured - public void methodWithProcedureParam(Procedure procedure) throws Exception { - this.onkostarApi.saveProcedure(procedure, false); - } - - @FormSecuredResult - public Patient methodWithPatientReturnValue(int id) { - var patient = new Patient(this.onkostarApi); - patient.setId(id); - return patient; - } - - @FormSecuredResult - public Procedure methodWithProcedureReturnValue(int id) { - var procedure = new Procedure(this.onkostarApi); - procedure.setId(id); - return procedure; - } + @FormSecuredResult + public Procedure methodWithProcedureReturnValue(int id) { + var procedure = new Procedure(this.onkostarApi); + procedure.setId(id); + return procedure; } - + } } diff --git a/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedPermissionEvaluatorTest.java b/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedPermissionEvaluatorTest.java index 1390b76..01e3399 100644 --- a/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedPermissionEvaluatorTest.java +++ b/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedPermissionEvaluatorTest.java @@ -19,9 +19,16 @@ package dev.dnpm.oshelper.security; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.when; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Patient; import de.itc.onkostar.api.Procedure; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -29,151 +36,177 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.security.core.Authentication; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.when; - @ExtendWith(MockitoExtension.class) class PersonPoolBasedPermissionEvaluatorTest { - private IOnkostarApi onkostarApi; - - private Authentication dummyAuthentication; - - private PersonPoolBasedPermissionEvaluator permissionEvaluator; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock SecurityService securityService, - @Mock DummyAuthentication dummyAuthentication - ) { - this.onkostarApi = onkostarApi; - this.dummyAuthentication = dummyAuthentication; - - this.permissionEvaluator = new PersonPoolBasedPermissionEvaluator( - onkostarApi, securityService - ); - - when(securityService.getPersonPoolIdsForPermission(any(Authentication.class), any(PermissionType.class))).thenReturn(List.of("Pool2", "Pool3", "Pool5")); - } - - @Test - void testShouldGrantPermissionByPatientObject() { - var object = new Patient(onkostarApi); - object.setPersonPoolCode("Pool2"); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldGrantPermissionByPatientIdAndType() { - doAnswer(invocationOnMock -> { - var object = new Patient(onkostarApi); - object.setPersonPoolCode("Pool2"); - return object; - }).when(onkostarApi).getPatient(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, PersonPoolBasedPermissionEvaluator.PATIENT, PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldDenyPermissionByPatientObject() { - var object = new Patient(onkostarApi); - object.setPersonPoolCode("Pool1"); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - - assertThat(actual).isFalse(); - } - - @Test - void testShouldDenyPermissionByPatientIdAndType() { - doAnswer(invocationOnMock -> { - var object = new Patient(onkostarApi); - object.setPersonPoolCode("Pool1"); - return object; - }).when(onkostarApi).getPatient(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, PersonPoolBasedPermissionEvaluator.PATIENT, PermissionType.READ); - - assertThat(actual).isFalse(); - } - - @Test - void testShouldGrantPermissionByProcedureObject() { - var patient = new Patient(onkostarApi); - patient.setId(1); - patient.setPersonPoolCode("Pool2"); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - object.setPatient(patient); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldGrantPermissionByProcedureIdAndType() { - doAnswer(invocationOnMock -> { - var patient = new Patient(onkostarApi); - patient.setId(1); - patient.setPersonPoolCode("Pool2"); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - object.setPatient(patient); - - return object; - }).when(onkostarApi).getProcedure(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 456, PersonPoolBasedPermissionEvaluator.PROCEDURE, PermissionType.READ); - - assertThat(actual).isTrue(); - } - - @Test - void testShouldDenyPermissionByProcedureObject() { - var patient = new Patient(onkostarApi); - patient.setId(1); - patient.setPersonPoolCode("Pool1"); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - object.setPatient(patient); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); - - assertThat(actual).isFalse(); - } - - @Test - void testShouldDenyPermissionByProcedureIdAndType() { - doAnswer(invocationOnMock -> { - var patient = new Patient(onkostarApi); - patient.setId(1); - patient.setPersonPoolCode("Pool1"); - - var object = new Procedure(onkostarApi); - object.setFormName("OS.Form1"); - object.setPatient(patient); - - return object; - }).when(onkostarApi).getProcedure(anyInt()); - - var actual = permissionEvaluator.hasPermission(this.dummyAuthentication, 123, PersonPoolBasedPermissionEvaluator.PROCEDURE, PermissionType.READ); - - assertThat(actual).isFalse(); - } - -} \ No newline at end of file + private IOnkostarApi onkostarApi; + + private Authentication dummyAuthentication; + + private PersonPoolBasedPermissionEvaluator permissionEvaluator; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock SecurityService securityService, + @Mock DummyAuthentication dummyAuthentication) { + this.onkostarApi = onkostarApi; + this.dummyAuthentication = dummyAuthentication; + + this.permissionEvaluator = new PersonPoolBasedPermissionEvaluator(onkostarApi, securityService); + + when(securityService.getPersonPoolIdsForPermission( + any(Authentication.class), any(PermissionType.class))) + .thenReturn(List.of("Pool2", "Pool3", "Pool5")); + } + + @Test + void testShouldGrantPermissionByPatientObject() { + var object = new Patient(onkostarApi); + object.setPersonPoolCode("Pool2"); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldGrantPermissionByPatientIdAndType() { + doAnswer( + invocationOnMock -> { + var object = new Patient(onkostarApi); + object.setPersonPoolCode("Pool2"); + return object; + }) + .when(onkostarApi) + .getPatient(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + PersonPoolBasedPermissionEvaluator.PATIENT, + PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldDenyPermissionByPatientObject() { + var object = new Patient(onkostarApi); + object.setPersonPoolCode("Pool1"); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + + assertThat(actual).isFalse(); + } + + @Test + void testShouldDenyPermissionByPatientIdAndType() { + doAnswer( + invocationOnMock -> { + var object = new Patient(onkostarApi); + object.setPersonPoolCode("Pool1"); + return object; + }) + .when(onkostarApi) + .getPatient(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + PersonPoolBasedPermissionEvaluator.PATIENT, + PermissionType.READ); + + assertThat(actual).isFalse(); + } + + @Test + void testShouldGrantPermissionByProcedureObject() { + var patient = new Patient(onkostarApi); + patient.setId(1); + patient.setPersonPoolCode("Pool2"); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + object.setPatient(patient); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldGrantPermissionByProcedureIdAndType() { + doAnswer( + invocationOnMock -> { + var patient = new Patient(onkostarApi); + patient.setId(1); + patient.setPersonPoolCode("Pool2"); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + object.setPatient(patient); + + return object; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 456, + PersonPoolBasedPermissionEvaluator.PROCEDURE, + PermissionType.READ); + + assertThat(actual).isTrue(); + } + + @Test + void testShouldDenyPermissionByProcedureObject() { + var patient = new Patient(onkostarApi); + patient.setId(1); + patient.setPersonPoolCode("Pool1"); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + object.setPatient(patient); + + var actual = + permissionEvaluator.hasPermission(this.dummyAuthentication, object, PermissionType.READ); + + assertThat(actual).isFalse(); + } + + @Test + void testShouldDenyPermissionByProcedureIdAndType() { + doAnswer( + invocationOnMock -> { + var patient = new Patient(onkostarApi); + patient.setId(1); + patient.setPersonPoolCode("Pool1"); + + var object = new Procedure(onkostarApi); + object.setFormName("OS.Form1"); + object.setPatient(patient); + + return object; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + var actual = + permissionEvaluator.hasPermission( + this.dummyAuthentication, + 123, + PersonPoolBasedPermissionEvaluator.PROCEDURE, + PermissionType.READ); + + assertThat(actual).isFalse(); + } +} diff --git a/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedSecurityAspectsTest.java b/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedSecurityAspectsTest.java index 4f03a64..cf7706c 100644 --- a/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedSecurityAspectsTest.java +++ b/src/test/java/dev/dnpm/oshelper/security/PersonPoolBasedSecurityAspectsTest.java @@ -19,6 +19,10 @@ package dev.dnpm.oshelper.security; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Patient; import de.itc.onkostar.api.Procedure; @@ -29,154 +33,153 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.aop.aspectj.annotation.AspectJProxyFactory; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class PersonPoolBasedSecurityAspectsTest { - private DummyClass dummyClass; - - private IOnkostarApi onkostarApi; - - private PersonPoolBasedPermissionEvaluator permissionEvaluator; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock PersonPoolBasedPermissionEvaluator permissionEvaluator - ) { - this.onkostarApi = onkostarApi; - this.permissionEvaluator = permissionEvaluator; - - // Create proxied instance of DummyClass as done within Onkostar using Spring AOP - var dummyClass = new DummyClass(onkostarApi); - AspectJProxyFactory factory = new AspectJProxyFactory(dummyClass); - PersonPoolBasedSecurityAspects securityAspects = new PersonPoolBasedSecurityAspects(this.permissionEvaluator); - factory.addAspect(securityAspects); - this.dummyClass = factory.getProxy(); + private DummyClass dummyClass; + + private IOnkostarApi onkostarApi; + + private PersonPoolBasedPermissionEvaluator permissionEvaluator; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock PersonPoolBasedPermissionEvaluator permissionEvaluator) { + this.onkostarApi = onkostarApi; + this.permissionEvaluator = permissionEvaluator; + + // Create proxied instance of DummyClass as done within Onkostar using Spring AOP + var dummyClass = new DummyClass(onkostarApi); + AspectJProxyFactory factory = new AspectJProxyFactory(dummyClass); + PersonPoolBasedSecurityAspects securityAspects = + new PersonPoolBasedSecurityAspects(this.permissionEvaluator); + factory.addAspect(securityAspects); + this.dummyClass = factory.getProxy(); + } + + @Test + void testShouldPreventSecuredMethodCallWithPatientParam() { + when(this.permissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows( + Exception.class, + () -> this.dummyClass.methodWithPatientParam(new Patient(onkostarApi))); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithPatientParam() { + when(this.permissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); + + this.dummyClass.methodWithPatientParam(new Patient(onkostarApi)); + + verify(onkostarApi, times(1)).savePatient(any(Patient.class)); + } + + @Test + void testShouldPreventSecuredMethodCallWithProcedureParam() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows( + Exception.class, + () -> this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi))); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithProcedureParam() throws Exception { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(true); + + this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)); + + verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void testShouldPreventSecuredMethodCallWithPatientReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows(Exception.class, () -> this.dummyClass.methodWithPatientReturnValue(1)); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithPatientReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Patient.class), any(PermissionType.class))) + .thenReturn(true); + + var actual = this.dummyClass.methodWithPatientReturnValue(1); + + assertThat(actual).isNotNull(); + } + + @Test + void testShouldPreventSecuredMethodCallWithProcedureReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(false); + + var exception = + assertThrows(Exception.class, () -> this.dummyClass.methodWithProcedureReturnValue(1)); + assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + } + + @Test + void testShouldAllowSecuredMethodCallWithProcedureReturnValue() { + when(this.permissionEvaluator.hasPermission( + any(), any(Procedure.class), any(PermissionType.class))) + .thenReturn(true); + + var actual = this.dummyClass.methodWithProcedureReturnValue(1); + + assertThat(actual).isNotNull(); + } + + private static class DummyClass { + + private final IOnkostarApi onkostarApi; + + DummyClass(final IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; } - @Test - void testShouldPreventSecuredMethodCallWithPatientParam() { - when(this.permissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithPatientParam(new Patient(onkostarApi)) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + @PersonPoolSecured + public void methodWithPatientParam(Patient patient) { + this.onkostarApi.savePatient(patient); } - @Test - void testShouldAllowSecuredMethodCallWithPatientParam() { - when(this.permissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(true); - - this.dummyClass.methodWithPatientParam(new Patient(onkostarApi)); - - verify(onkostarApi, times(1)).savePatient(any(Patient.class)); + @PersonPoolSecured + public void methodWithProcedureParam(Procedure procedure) throws Exception { + this.onkostarApi.saveProcedure(procedure, false); } - @Test - void testShouldPreventSecuredMethodCallWithProcedureParam() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); + @PersonPoolSecuredResult + public Patient methodWithPatientReturnValue(int id) { + var patient = new Patient(this.onkostarApi); + patient.setId(id); + return patient; } - @Test - void testShouldAllowSecuredMethodCallWithProcedureParam() throws Exception { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(true); - - this.dummyClass.methodWithProcedureParam(new Procedure(onkostarApi)); - - verify(onkostarApi, times(1)).saveProcedure(any(Procedure.class), anyBoolean()); + @PersonPoolSecuredResult + public Procedure methodWithProcedureReturnValue(int id) { + var procedure = new Procedure(this.onkostarApi); + procedure.setId(id); + return procedure; } - - @Test - void testShouldPreventSecuredMethodCallWithPatientReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithPatientReturnValue(1) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); - } - - @Test - void testShouldAllowSecuredMethodCallWithPatientReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Patient.class), any(PermissionType.class))) - .thenReturn(true); - - var actual = this.dummyClass.methodWithPatientReturnValue(1); - - assertThat(actual).isNotNull(); - } - - @Test - void testShouldPreventSecuredMethodCallWithProcedureReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(false); - - var exception = assertThrows( - Exception.class, - () -> this.dummyClass.methodWithProcedureReturnValue(1) - ); - assertThat(exception).isExactlyInstanceOf(IllegalSecuredObjectAccessException.class); - } - - @Test - void testShouldAllowSecuredMethodCallWithProcedureReturnValue() { - when(this.permissionEvaluator.hasPermission(any(), any(Procedure.class), any(PermissionType.class))) - .thenReturn(true); - - var actual = this.dummyClass.methodWithProcedureReturnValue(1); - - assertThat(actual).isNotNull(); - } - - private static class DummyClass { - - private final IOnkostarApi onkostarApi; - - DummyClass(final IOnkostarApi onkostarApi) { - this.onkostarApi = onkostarApi; - } - - @PersonPoolSecured - public void methodWithPatientParam(Patient patient) { - this.onkostarApi.savePatient(patient); - } - - @PersonPoolSecured - public void methodWithProcedureParam(Procedure procedure) throws Exception { - this.onkostarApi.saveProcedure(procedure, false); - } - - @PersonPoolSecuredResult - public Patient methodWithPatientReturnValue(int id) { - var patient = new Patient(this.onkostarApi); - patient.setId(id); - return patient; - } - - @PersonPoolSecuredResult - public Procedure methodWithProcedureReturnValue(int id) { - var procedure = new Procedure(this.onkostarApi); - procedure.setId(id); - return procedure; - } - } - + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/SettingsServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/SettingsServiceTest.java index f0c53de..ce085eb 100644 --- a/src/test/java/dev/dnpm/oshelper/services/SettingsServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/SettingsServiceTest.java @@ -19,6 +19,10 @@ package dev.dnpm.oshelper.services; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.doAnswer; + import de.itc.db.dnpm.Setting; import dev.dnpm.oshelper.database.SettingsRepository; import org.junit.jupiter.api.BeforeEach; @@ -27,55 +31,50 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.anyString; -import static org.mockito.Mockito.doAnswer; - @ExtendWith(MockitoExtension.class) class SettingsServiceTest { - private SettingsRepository settingsRepository; + private SettingsRepository settingsRepository; - private SettingsService service; + private SettingsService service; - @BeforeEach - void setUp( - @Mock SettingsRepository settingsRepository - ) { - this.settingsRepository = settingsRepository; - this.service = new SettingsService(settingsRepository); - } + @BeforeEach + void setUp(@Mock SettingsRepository settingsRepository) { + this.settingsRepository = settingsRepository; + this.service = new SettingsService(settingsRepository); + } - @Test - void shouldReturnSID() { - doAnswer(invocationOnMock -> { - var name = invocationOnMock.getArgument(0, String.class); - if (null != name && name.equals("SID")) { + @Test + void shouldReturnSID() { + doAnswer( + invocationOnMock -> { + var name = invocationOnMock.getArgument(0, String.class); + if (null != name && name.equals("SID")) { return new Setting(1L, "SID", "12345"); - } - return null; - }).when(settingsRepository).findByName(anyString()); + } + return null; + }) + .when(settingsRepository) + .findByName(anyString()); - var actual = service.getSID(); - assertThat(actual) - .isPresent() - .contains("12345"); - } + var actual = service.getSID(); + assertThat(actual).isPresent().contains("12345"); + } - @Test - void shouldReturnSIDByName() { - doAnswer(invocationOnMock -> { - var name = invocationOnMock.getArgument(0, String.class); - if (null != name && name.equals("SID")) { + @Test + void shouldReturnSIDByName() { + doAnswer( + invocationOnMock -> { + var name = invocationOnMock.getArgument(0, String.class); + if (null != name && name.equals("SID")) { return new Setting(1L, "SID", "12345"); - } - return null; - }).when(settingsRepository).findByName(anyString()); - - var actual = service.getSetting("SID"); - assertThat(actual) - .isPresent() - .contains("12345"); - } + } + return null; + }) + .when(settingsRepository) + .findByName(anyString()); + var actual = service.getSetting("SID"); + assertThat(actual).isPresent().contains("12345"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/StudieTest.java b/src/test/java/dev/dnpm/oshelper/services/StudieTest.java index f8d64c2..b65760a 100644 --- a/src/test/java/dev/dnpm/oshelper/services/StudieTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/StudieTest.java @@ -19,56 +19,32 @@ package dev.dnpm.oshelper.services; +import static org.assertj.core.api.Assertions.assertThat; + import dev.dnpm.oshelper.dto.Studie; import org.junit.jupiter.api.Test; -import static org.assertj.core.api.Assertions.assertThat; - class StudieTest { - @Test - void shouldDetectStudieWithNctNumber() { - var studie = new Studie( - "Kat 1", - 1, - null, - "Nct-12345678", - "Teststudie 1", - "Teststudie 1", - true - ); - - assertThat(studie.getType()).isEqualTo(Studie.Type.NCT); - } + @Test + void shouldDetectStudieWithNctNumber() { + var studie = new Studie("Kat 1", 1, null, "Nct-12345678", "Teststudie 1", "Teststudie 1", true); - @Test - void shouldDetectStudieWithEudraCtNumber() { - var studie = new Studie( - "Kat 1", - 1, - null, - "2023-012345-12", - "Teststudie 1", - "Teststudie 1", - true - ); + assertThat(studie.getType()).isEqualTo(Studie.Type.NCT); + } - assertThat(studie.getType()).isEqualTo(Studie.Type.EUDRA_CT); - } + @Test + void shouldDetectStudieWithEudraCtNumber() { + var studie = + new Studie("Kat 1", 1, null, "2023-012345-12", "Teststudie 1", "Teststudie 1", true); - @Test - void shouldReturnStudieWithUnknownNumberScheme() { - var studie = new Studie( - "Kat 1", - 1, - "teststudie1", - null, - "Teststudie 1", - "Teststudie 1", - true - ); + assertThat(studie.getType()).isEqualTo(Studie.Type.EUDRA_CT); + } - assertThat(studie.getType()).isEqualTo(Studie.Type.UNKNOWN); - } + @Test + void shouldReturnStudieWithUnknownNumberScheme() { + var studie = new Studie("Kat 1", 1, "teststudie1", null, "Teststudie 1", "Teststudie 1", true); + assertThat(studie.getType()).isEqualTo(Studie.Type.UNKNOWN); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/consent/ConsentManagerServiceFactoryTest.java b/src/test/java/dev/dnpm/oshelper/services/consent/ConsentManagerServiceFactoryTest.java index 57e505b..7d086de 100644 --- a/src/test/java/dev/dnpm/oshelper/services/consent/ConsentManagerServiceFactoryTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/consent/ConsentManagerServiceFactoryTest.java @@ -19,7 +19,13 @@ package dev.dnpm.oshelper.services.consent; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + import de.itc.onkostar.api.IOnkostarApi; +import java.util.Map; +import java.util.Set; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; @@ -27,43 +33,33 @@ import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.Map; -import java.util.Set; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.when; - @ExtendWith(MockitoExtension.class) class ConsentManagerServiceFactoryTest { - private IOnkostarApi onkostarApi; - - private ConsentManagerServiceFactory consentManagerServiceFactory; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.consentManagerServiceFactory = new ConsentManagerServiceFactory(onkostarApi); - } + private ConsentManagerServiceFactory consentManagerServiceFactory; - private static Set>> expectedMappings() { - return Map.ofEntries( - Map.entry("MR.Consent", MrConsentManagerService.class), - Map.entry("Excel-Formular", UkwConsentManagerService.class) - ).entrySet(); - } + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.consentManagerServiceFactory = new ConsentManagerServiceFactory(onkostarApi); + } - @ParameterizedTest - @MethodSource("expectedMappings") - void testShouldMapFormNameToService(Map.Entry> expectedMapping) { - when(onkostarApi.getGlobalSetting(anyString())).thenReturn(expectedMapping.getKey()); + private static Set>> expectedMappings() { + return Map.ofEntries( + Map.entry("MR.Consent", MrConsentManagerService.class), + Map.entry("Excel-Formular", UkwConsentManagerService.class)) + .entrySet(); + } - var actual = consentManagerServiceFactory.currentUsableInstance(); + @ParameterizedTest + @MethodSource("expectedMappings") + void testShouldMapFormNameToService(Map.Entry> expectedMapping) { + when(onkostarApi.getGlobalSetting(anyString())).thenReturn(expectedMapping.getKey()); - assertThat(actual).isExactlyInstanceOf(expectedMapping.getValue()); - } + var actual = consentManagerServiceFactory.currentUsableInstance(); + assertThat(actual).isExactlyInstanceOf(expectedMapping.getValue()); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/consent/MrConsentManagerServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/consent/MrConsentManagerServiceTest.java index 12b9208..b747987 100644 --- a/src/test/java/dev/dnpm/oshelper/services/consent/MrConsentManagerServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/consent/MrConsentManagerServiceTest.java @@ -19,6 +19,9 @@ package dev.dnpm.oshelper.services.consent; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Procedure; import org.hibernate.SQLQuery; @@ -32,47 +35,42 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class MrConsentManagerServiceTest { - private IOnkostarApi onkostarApi; - - private MrConsentManagerService service; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.service = new MrConsentManagerService(onkostarApi); - } + private MrConsentManagerService service; - @Test - void testShouldCreateSqlQueriesWithRelatedEntityIds() { - var sessionFactory = mock(SessionFactory.class); - var session = mock(Session.class); - var query = mock(SQLQuery.class); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.service = new MrConsentManagerService(onkostarApi); + } - when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); - when(sessionFactory.getCurrentSession()).thenReturn(session); - when(session.createSQLQuery(anyString())).thenReturn(query); - when(query.addScalar(anyString(), any(Type.class))).thenReturn(query); - when(query.uniqueResult()).thenReturn(""); + @Test + void testShouldCreateSqlQueriesWithRelatedEntityIds() { + var sessionFactory = mock(SessionFactory.class); + var session = mock(Session.class); + var query = mock(SQLQuery.class); - var dummyProzedur = new Procedure(this.onkostarApi); - dummyProzedur.setId(111); - dummyProzedur.setPatientId(123); + when(onkostarApi.getSessionFactory()).thenReturn(sessionFactory); + when(sessionFactory.getCurrentSession()).thenReturn(session); + when(session.createSQLQuery(anyString())).thenReturn(query); + when(query.addScalar(anyString(), any(Type.class))).thenReturn(query); + when(query.uniqueResult()).thenReturn(""); - this.service.applyConsent(dummyProzedur); + var dummyProzedur = new Procedure(this.onkostarApi); + dummyProzedur.setId(111); + dummyProzedur.setPatientId(123); - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(session, times(2)).createSQLQuery(argumentCaptor.capture()); - assertThat(argumentCaptor.getAllValues()).hasSize(2); - assertThat(argumentCaptor.getAllValues().get(0)).contains("where entity_id = '111'"); - assertThat(argumentCaptor.getAllValues().get(1)).contains("WHERE patient_id = 123 AND geloescht = 0"); - } + this.service.applyConsent(dummyProzedur); + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(session, times(2)).createSQLQuery(argumentCaptor.capture()); + assertThat(argumentCaptor.getAllValues()).hasSize(2); + assertThat(argumentCaptor.getAllValues().get(0)).contains("where entity_id = '111'"); + assertThat(argumentCaptor.getAllValues().get(1)) + .contains("WHERE patient_id = 123 AND geloescht = 0"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/consent/UkwConsentManagerServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/consent/UkwConsentManagerServiceTest.java index f21492d..e28dd64 100644 --- a/src/test/java/dev/dnpm/oshelper/services/consent/UkwConsentManagerServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/consent/UkwConsentManagerServiceTest.java @@ -19,9 +19,14 @@ package dev.dnpm.oshelper.services.consent; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; +import java.sql.Date; +import java.time.Instant; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -29,129 +34,125 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.sql.Date; -import java.time.Instant; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class UkwConsentManagerServiceTest { - private IOnkostarApi onkostarApi; - - private UkwConsentManagerService service; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.service = new UkwConsentManagerService(onkostarApi); - } + private IOnkostarApi onkostarApi; - @Test - void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentAvailable() throws Exception { + private UkwConsentManagerService service; - var excelForm = new Procedure(this.onkostarApi); - excelForm.setId(111); - excelForm.setPatientId(123); - excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.service = new UkwConsentManagerService(onkostarApi); + } - var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); - dnpmKlinikAnamneseForm.setId(2); - dnpmKlinikAnamneseForm.setPatientId(123); + @Test + void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentAvailable() throws Exception { - when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); + var excelForm = new Procedure(this.onkostarApi); + excelForm.setId(111); + excelForm.setPatientId(123); + excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); - this.service.applyConsent(excelForm); + var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); + dnpmKlinikAnamneseForm.setId(2); + dnpmKlinikAnamneseForm.setPatientId(123); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); - } + when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); - @Test - void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentDateAvailable() throws Exception { + this.service.applyConsent(excelForm); - var consentSubForm = new Procedure(this.onkostarApi); - consentSubForm.setId(1); - consentSubForm.setPatientId(123); - consentSubForm.setValue("status", new Item("status", "accepted")); + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); + } + @Test + void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentDateAvailable() + throws Exception { - var excelForm = new Procedure(this.onkostarApi); - excelForm.setId(111); - excelForm.setPatientId(123); - excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); - excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); + var consentSubForm = new Procedure(this.onkostarApi); + consentSubForm.setId(1); + consentSubForm.setPatientId(123); + consentSubForm.setValue("status", new Item("status", "accepted")); - var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); - dnpmKlinikAnamneseForm.setId(2); - dnpmKlinikAnamneseForm.setPatientId(123); + var excelForm = new Procedure(this.onkostarApi); + excelForm.setId(111); + excelForm.setPatientId(123); + excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); + excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); - when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); + var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); + dnpmKlinikAnamneseForm.setId(2); + dnpmKlinikAnamneseForm.setPatientId(123); - this.service.applyConsent(excelForm); + when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); - } + this.service.applyConsent(excelForm); - @Test - void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentValueAvailable() throws Exception { + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); + } - var consentSubForm = new Procedure(this.onkostarApi); - consentSubForm.setId(1); - consentSubForm.setPatientId(123); - consentSubForm.setStartDate(Date.from(Instant.parse("2023-04-03T12:00:00Z"))); - consentSubForm.setValue("datum", new Item("datum", Date.from(Instant.parse("2023-04-03T12:00:00Z")))); + @Test + void testShouldSkipUpdateRelatedDnpmKlinikAnamneseFormIfNoConsentValueAvailable() + throws Exception { - var excelForm = new Procedure(this.onkostarApi); - excelForm.setId(111); - excelForm.setPatientId(123); - excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); - excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); + var consentSubForm = new Procedure(this.onkostarApi); + consentSubForm.setId(1); + consentSubForm.setPatientId(123); + consentSubForm.setStartDate(Date.from(Instant.parse("2023-04-03T12:00:00Z"))); + consentSubForm.setValue( + "datum", new Item("datum", Date.from(Instant.parse("2023-04-03T12:00:00Z")))); - var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); - dnpmKlinikAnamneseForm.setId(2); - dnpmKlinikAnamneseForm.setPatientId(123); + var excelForm = new Procedure(this.onkostarApi); + excelForm.setId(111); + excelForm.setPatientId(123); + excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); + excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); - when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); + var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); + dnpmKlinikAnamneseForm.setId(2); + dnpmKlinikAnamneseForm.setPatientId(123); - this.service.applyConsent(excelForm); + when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); - verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); - } + this.service.applyConsent(excelForm); - @Test - void testShouldUpdateRelatedDnpmKlinikAnamneseFormOnFormSave() throws Exception { + verify(onkostarApi, times(0)).saveProcedure(any(Procedure.class), anyBoolean()); + } - var consentSubForm = new Procedure(this.onkostarApi); - consentSubForm.setId(1); - consentSubForm.setPatientId(123); - consentSubForm.setStartDate(Date.from(Instant.parse("2023-04-03T12:00:00Z"))); - consentSubForm.setValue("datum", new Item("datum", Date.from(Instant.parse("2023-04-03T12:00:00Z")))); - consentSubForm.setValue("status", new Item("status", "accepted")); + @Test + void testShouldUpdateRelatedDnpmKlinikAnamneseFormOnFormSave() throws Exception { - var excelForm = new Procedure(this.onkostarApi); - excelForm.setId(111); - excelForm.setPatientId(123); - excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); - excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); + var consentSubForm = new Procedure(this.onkostarApi); + consentSubForm.setId(1); + consentSubForm.setPatientId(123); + consentSubForm.setStartDate(Date.from(Instant.parse("2023-04-03T12:00:00Z"))); + consentSubForm.setValue( + "datum", new Item("datum", Date.from(Instant.parse("2023-04-03T12:00:00Z")))); + consentSubForm.setValue("status", new Item("status", "accepted")); - var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); - dnpmKlinikAnamneseForm.setId(2); - dnpmKlinikAnamneseForm.setPatientId(123); + var excelForm = new Procedure(this.onkostarApi); + excelForm.setId(111); + excelForm.setPatientId(123); + excelForm.setValue("refdnpmklinikanamnese", new Item("refdnpmklinikanamnese", 2)); + excelForm.addSubProcedure("ufdnpmconsent", consentSubForm); - when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); + var dnpmKlinikAnamneseForm = new Procedure(this.onkostarApi); + dnpmKlinikAnamneseForm.setId(2); + dnpmKlinikAnamneseForm.setPatientId(123); - this.service.applyConsent(excelForm); + when(onkostarApi.getProcedure(anyInt())).thenReturn(dnpmKlinikAnamneseForm); - var argumentCaptor = ArgumentCaptor.forClass(Procedure.class); - verify(onkostarApi, times(1)).saveProcedure(argumentCaptor.capture(), anyBoolean()); + this.service.applyConsent(excelForm); - var savedForm = argumentCaptor.getValue(); - assertThat(savedForm).isExactlyInstanceOf(Procedure.class); - assertThat(savedForm.getValue("ConsentStatusEinwilligungDNPM").getString()).isEqualTo("accepted"); - assertThat(savedForm.getValue("ConsentDatumEinwilligungDNPM").getDate()).isEqualTo("2023-04-03T12:00:00Z"); - } + var argumentCaptor = ArgumentCaptor.forClass(Procedure.class); + verify(onkostarApi, times(1)).saveProcedure(argumentCaptor.capture(), anyBoolean()); + var savedForm = argumentCaptor.getValue(); + assertThat(savedForm).isExactlyInstanceOf(Procedure.class); + assertThat(savedForm.getValue("ConsentStatusEinwilligungDNPM").getString()) + .isEqualTo("accepted"); + assertThat(savedForm.getValue("ConsentDatumEinwilligungDNPM").getDate()) + .isEqualTo("2023-04-03T12:00:00Z"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java index 61f82fa..5182160 100644 --- a/src/test/java/dev/dnpm/oshelper/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/molekulargenetik/OsMolekluargenetikFormServiceTest.java @@ -19,50 +19,49 @@ package dev.dnpm.oshelper.services.molekulargenetik; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import static org.assertj.core.api.Assertions.assertThat; - class OsMolekluargenetikFormServiceTest { - private OsMolekulargenetikFormService service; - - @BeforeEach - void setup() { - this.service = new OsMolekulargenetikFormService(); - } + private OsMolekulargenetikFormService service; - @Test - void testShouldReturnVariants() { + @BeforeEach + void setup() { + this.service = new OsMolekulargenetikFormService(); + } - var procedure = new Procedure(null); - procedure.setId(123); - procedure.setFormName("OS.Molekulargenetik"); + @Test + void testShouldReturnVariants() { - var subProcedure1 = new Procedure(null); - subProcedure1.setId(1123); - subProcedure1.setFormName("OS.Molekulargenetische Untersuchung"); - subProcedure1.setValue("Ergebnis", new Item("Ergebnis", "P")); - subProcedure1.setValue("Untersucht", new Item("Untersucht", "BRAF")); - subProcedure1.setValue("ExonInt", new Item("ExonInt", 123)); - subProcedure1.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure1); + var procedure = new Procedure(null); + procedure.setId(123); + procedure.setFormName("OS.Molekulargenetik"); - var subProcedure2 = new Procedure(null); - subProcedure2.setId(2123); - subProcedure2.setFormName("OS.Molekulargenetische Untersuchung"); - subProcedure2.setValue("Ergebnis", new Item("Ergebnis", "CNV")); - subProcedure2.setValue("Untersucht", new Item("Untersucht", "BRAF")); - subProcedure2.setValue("ExonInt", new Item("ExonInt", 123)); - subProcedure2.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); - procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure2); + var subProcedure1 = new Procedure(null); + subProcedure1.setId(1123); + subProcedure1.setFormName("OS.Molekulargenetische Untersuchung"); + subProcedure1.setValue("Ergebnis", new Item("Ergebnis", "P")); + subProcedure1.setValue("Untersucht", new Item("Untersucht", "BRAF")); + subProcedure1.setValue("ExonInt", new Item("ExonInt", 123)); + subProcedure1.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure1); - var actual = service.getVariants(procedure); + var subProcedure2 = new Procedure(null); + subProcedure2.setId(2123); + subProcedure2.setFormName("OS.Molekulargenetische Untersuchung"); + subProcedure2.setValue("Ergebnis", new Item("Ergebnis", "CNV")); + subProcedure2.setValue("Untersucht", new Item("Untersucht", "BRAF")); + subProcedure2.setValue("ExonInt", new Item("ExonInt", 123)); + subProcedure2.setValue("Pathogenitaetsklasse", new Item("Pathogenitaetsklasse", "2")); + procedure.addSubProcedure("MolekulargenetischeUntersuchung", subProcedure2); - assertThat(actual).hasSize(2); - } + var actual = service.getVariants(procedure); + assertThat(actual).hasSize(2); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/mtb/MrMtbAnmeldungToProtocolMapperTest.java b/src/test/java/dev/dnpm/oshelper/services/mtb/MrMtbAnmeldungToProtocolMapperTest.java index 405853c..b8e43b3 100644 --- a/src/test/java/dev/dnpm/oshelper/services/mtb/MrMtbAnmeldungToProtocolMapperTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/mtb/MrMtbAnmeldungToProtocolMapperTest.java @@ -19,140 +19,141 @@ package dev.dnpm.oshelper.services.mtb; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doAnswer; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; +import java.util.Set; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.Set; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.anyInt; -import static org.mockito.Mockito.doAnswer; - @ExtendWith(MockitoExtension.class) class MrMtbAnmeldungToProtocolMapperTest { - private IOnkostarApi onkostarApi; - - private MrMtbAnmeldungToProtocolMapper mapper; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.mapper = new MrMtbAnmeldungToProtocolMapper(onkostarApi); - } - - @Test - void testShouldMapCompletedForm() { - var anmeldung = new Procedure(onkostarApi); - anmeldung.setId(1); - anmeldung.setFormName("MR.MTB_Anmeldung"); - anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); - anmeldung.setValue("Empfehlung", new Item("Empfehlung", 2)); - - var empfehlung = new Procedure(onkostarApi); - empfehlung.setId(2); - empfehlung.setFormName("MR.MTB_Empfehlung"); - - var einzelempfehlung1 = new Procedure(onkostarApi); - einzelempfehlung1.setId(10); - einzelempfehlung1.setFormName("MR.MTB_Einzelempfehlung"); - einzelempfehlung1.setValue("Prioritaet", new Item("Empfehlungsprio", 1)); - einzelempfehlung1.setValue("Empfehlung", new Item("Empfehlung", "Empfehlung1")); - - var einzelempfehlung2 = new Procedure(onkostarApi); - einzelempfehlung2.setId(20); - einzelempfehlung2.setFormName("MR.MTB_Einzelempfehlung"); - einzelempfehlung2.setValue("Prioritaet", new Item("Empfehlungsprio", 2)); - einzelempfehlung2.setValue("Empfehlung", new Item("Empfehlung", "Empfehlung2")); - - doAnswer(invocationOnMock -> { - var procedureId = invocationOnMock.getArgument(0, Integer.class); - if (2 == procedureId) { + private IOnkostarApi onkostarApi; + + private MrMtbAnmeldungToProtocolMapper mapper; + + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.mapper = new MrMtbAnmeldungToProtocolMapper(onkostarApi); + } + + @Test + void testShouldMapCompletedForm() { + var anmeldung = new Procedure(onkostarApi); + anmeldung.setId(1); + anmeldung.setFormName("MR.MTB_Anmeldung"); + anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); + anmeldung.setValue("Empfehlung", new Item("Empfehlung", 2)); + + var empfehlung = new Procedure(onkostarApi); + empfehlung.setId(2); + empfehlung.setFormName("MR.MTB_Empfehlung"); + + var einzelempfehlung1 = new Procedure(onkostarApi); + einzelempfehlung1.setId(10); + einzelempfehlung1.setFormName("MR.MTB_Einzelempfehlung"); + einzelempfehlung1.setValue("Prioritaet", new Item("Empfehlungsprio", 1)); + einzelempfehlung1.setValue("Empfehlung", new Item("Empfehlung", "Empfehlung1")); + + var einzelempfehlung2 = new Procedure(onkostarApi); + einzelempfehlung2.setId(20); + einzelempfehlung2.setFormName("MR.MTB_Einzelempfehlung"); + einzelempfehlung2.setValue("Prioritaet", new Item("Empfehlungsprio", 2)); + einzelempfehlung2.setValue("Empfehlung", new Item("Empfehlung", "Empfehlung2")); + + doAnswer( + invocationOnMock -> { + var procedureId = invocationOnMock.getArgument(0, Integer.class); + if (2 == procedureId) { return empfehlung; - } else if (10 == procedureId) { + } else if (10 == procedureId) { return einzelempfehlung1; - } else if (20 == procedureId) { + } else if (20 == procedureId) { return einzelempfehlung2; - } - return null; - }).when(onkostarApi).getProcedure(anyInt()); - - doAnswer(invocationOnMock -> { - var procedureId = invocationOnMock.getArgument(0, Integer.class); - if (2 == procedureId) { + } + return null; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + doAnswer( + invocationOnMock -> { + var procedureId = invocationOnMock.getArgument(0, Integer.class); + if (2 == procedureId) { return Set.of(einzelempfehlung1, einzelempfehlung2); - } - return null; - }).when(onkostarApi).getSubprocedures(anyInt()); - - var actual = this.mapper.apply(anmeldung); - - assertThat(actual) - .isPresent() - .contains( - "Fragestellung:\nFrage?\n\n" - + "Empfehlung:\nEmpfehlung1\n\n" - + "Empfehlung:\nEmpfehlung2" - ); - } - - @Test - void testShouldMapFormWithMissingEinzelempfehlungen() { - var anmeldung = new Procedure(onkostarApi); - anmeldung.setId(1); - anmeldung.setFormName("MR.MTB_Anmeldung"); - anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); - anmeldung.setValue("Empfehlung", new Item("Empfehlung", 2)); - - var empfehlung = new Procedure(onkostarApi); - empfehlung.setId(2); - empfehlung.setFormName("MR.MTB_Empfehlung"); - - doAnswer(invocationOnMock -> { - var procedureId = invocationOnMock.getArgument(0, Integer.class); - if (2 == procedureId) { + } + return null; + }) + .when(onkostarApi) + .getSubprocedures(anyInt()); + + var actual = this.mapper.apply(anmeldung); + + assertThat(actual) + .isPresent() + .contains( + "Fragestellung:\nFrage?\n\n" + + "Empfehlung:\nEmpfehlung1\n\n" + + "Empfehlung:\nEmpfehlung2"); + } + + @Test + void testShouldMapFormWithMissingEinzelempfehlungen() { + var anmeldung = new Procedure(onkostarApi); + anmeldung.setId(1); + anmeldung.setFormName("MR.MTB_Anmeldung"); + anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); + anmeldung.setValue("Empfehlung", new Item("Empfehlung", 2)); + + var empfehlung = new Procedure(onkostarApi); + empfehlung.setId(2); + empfehlung.setFormName("MR.MTB_Empfehlung"); + + doAnswer( + invocationOnMock -> { + var procedureId = invocationOnMock.getArgument(0, Integer.class); + if (2 == procedureId) { return empfehlung; - } - return null; - }).when(onkostarApi).getProcedure(anyInt()); + } + return null; + }) + .when(onkostarApi) + .getProcedure(anyInt()); - var actual = this.mapper.apply(anmeldung); + var actual = this.mapper.apply(anmeldung); - assertThat(actual) - .isPresent() - .contains("Fragestellung:\nFrage?"); - } + assertThat(actual).isPresent().contains("Fragestellung:\nFrage?"); + } - @Test - void testShouldMapFormWithMissingEmpfehlung() { - var anmeldung = new Procedure(onkostarApi); - anmeldung.setId(1); - anmeldung.setFormName("MR.MTB_Anmeldung"); - anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); + @Test + void testShouldMapFormWithMissingEmpfehlung() { + var anmeldung = new Procedure(onkostarApi); + anmeldung.setId(1); + anmeldung.setFormName("MR.MTB_Anmeldung"); + anmeldung.setValue("Fragestellung", new Item("Fragestellung", "Frage?")); - var actual = this.mapper.apply(anmeldung); + var actual = this.mapper.apply(anmeldung); - assertThat(actual) - .isPresent() - .contains("Fragestellung:\nFrage?"); - } + assertThat(actual).isPresent().contains("Fragestellung:\nFrage?"); + } - @Test - void testShouldMapFormWithMissingFragestellungAndEmpfehlung() { - var anmeldung = new Procedure(onkostarApi); - anmeldung.setId(1); - anmeldung.setFormName("MR.MTB_Anmeldung"); + @Test + void testShouldMapFormWithMissingFragestellungAndEmpfehlung() { + var anmeldung = new Procedure(onkostarApi); + anmeldung.setId(1); + anmeldung.setFormName("MR.MTB_Anmeldung"); - var actual = this.mapper.apply(anmeldung); + var actual = this.mapper.apply(anmeldung); - assertThat(actual).isEmpty(); - } + assertThat(actual).isEmpty(); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzToProtocolMapperTest.java b/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzToProtocolMapperTest.java index ac86bb6..7ab8ecf 100644 --- a/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzToProtocolMapperTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzToProtocolMapperTest.java @@ -19,48 +19,44 @@ package dev.dnpm.oshelper.services.mtb; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; +import java.time.Instant; +import java.util.Date; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.util.Date; - -import static org.assertj.core.api.Assertions.assertThat; - @ExtendWith(MockitoExtension.class) class OsTumorkonferenzToProtocolMapperTest { - private IOnkostarApi onkostarApi; - - private OsTumorkonferenzToProtocolMapper mapper; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.mapper = new OsTumorkonferenzToProtocolMapper(); - } + private OsTumorkonferenzToProtocolMapper mapper; - @Test - void testShouldReturnMtbProtocolForDefaultImplementation() { - var procedure = new Procedure(onkostarApi); - procedure.setFormName("OS.Tumorkonferenz"); - procedure.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z"))); - procedure.setValue("Fragestellung", new Item("Fragestellung", "Test ok?")); - procedure.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!")); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.mapper = new OsTumorkonferenzToProtocolMapper(); + } - var actual = mapper.apply(procedure); + @Test + void testShouldReturnMtbProtocolForDefaultImplementation() { + var procedure = new Procedure(onkostarApi); + procedure.setFormName("OS.Tumorkonferenz"); + procedure.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z"))); + procedure.setValue("Fragestellung", new Item("Fragestellung", "Test ok?")); + procedure.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!")); - assertThat(actual) - .isPresent() - .contains("Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!"); - } + var actual = mapper.apply(procedure); + assertThat(actual) + .isPresent() + .contains("Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapperTest.java b/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapperTest.java index ba606ae..0c10371 100644 --- a/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapperTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/mtb/OsTumorkonferenzVarianteUkwToProtocolMapperTest.java @@ -19,48 +19,44 @@ package dev.dnpm.oshelper.services.mtb; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; +import java.time.Instant; +import java.util.Date; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.util.Date; - -import static org.assertj.core.api.Assertions.assertThat; - @ExtendWith(MockitoExtension.class) class OsTumorkonferenzVarianteUkwToProtocolMapperTest { - private IOnkostarApi onkostarApi; - - private OsTumorkonferenzVarianteUkwToProtocolMapper mapper; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.mapper = new OsTumorkonferenzVarianteUkwToProtocolMapper(); - } + private OsTumorkonferenzVarianteUkwToProtocolMapper mapper; - @Test - void testShouldReturnMtbProtocolForDefaultImplementation() { - var procedure = new Procedure(onkostarApi); - procedure.setFormName("OS.Tumorkonferenz.VarianteUKW"); - procedure.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z"))); - procedure.setValue("Fragestellung", new Item("Fragestellung", "Test ok?")); - procedure.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!")); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.mapper = new OsTumorkonferenzVarianteUkwToProtocolMapper(); + } - var actual = mapper.apply(procedure); + @Test + void testShouldReturnMtbProtocolForDefaultImplementation() { + var procedure = new Procedure(onkostarApi); + procedure.setFormName("OS.Tumorkonferenz.VarianteUKW"); + procedure.setStartDate(Date.from(Instant.parse("2023-01-01T00:00:00Z"))); + procedure.setValue("Fragestellung", new Item("Fragestellung", "Test ok?")); + procedure.setValue("Empfehlung", new Item("Empfehlung", "Rerun Test if not ok!")); - assertThat(actual) - .isPresent() - .contains("Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!"); - } + var actual = mapper.apply(procedure); + assertThat(actual) + .isPresent() + .contains("Fragestellung:\nTest ok?\n\nEmpfehlung:\nRerun Test if not ok!"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/strahlentherapie/DefaultStrahlentherapieServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/strahlentherapie/DefaultStrahlentherapieServiceTest.java index 8457dea..16436bd 100644 --- a/src/test/java/dev/dnpm/oshelper/services/strahlentherapie/DefaultStrahlentherapieServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/strahlentherapie/DefaultStrahlentherapieServiceTest.java @@ -19,8 +19,16 @@ package dev.dnpm.oshelper.services.strahlentherapie; -import dev.dnpm.oshelper.services.SettingsService; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.*; +import dev.dnpm.oshelper.services.SettingsService; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Optional; import org.assertj.core.util.Lists; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -29,95 +37,95 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.util.ArrayList; -import java.util.Date; -import java.util.List; -import java.util.Optional; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class DefaultStrahlentherapieServiceTest { - private IOnkostarApi onkostarApi; - - private SettingsService settingsService; - - private DefaultStrahlentherapieService service; - - @BeforeEach - void setup(@Mock IOnkostarApi onkostarApi, @Mock SettingsService settingsService) { - this.onkostarApi = onkostarApi; - this.settingsService = settingsService; - this.service = new DefaultStrahlentherapieService(onkostarApi, settingsService); - } - - @Test - void testShouldRequestProceduresWithDefaultFormName() { - when(this.settingsService.getSetting(anyString())).thenReturn(Optional.empty()); - - doAnswer(invocationOnMock -> { - var procedure = new Procedure(onkostarApi); - procedure.setId(1); - procedure.setFormName("OS.Strahlentherapie"); - procedure.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); - procedure.setEditState(ProcedureEditStateType.COMPLETED); - procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - return Lists.list(procedure); - }).when(this.onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - doAnswer(invocationOnMock -> { - var disease = new Disease(onkostarApi); - disease.setId(1); - disease.setPatientId(123); - return Lists.list(disease); - }).when(this.onkostarApi).getDiseasesByPatientId(anyInt()); - - var patient = new Patient(onkostarApi); - patient.setId(123); - - service.ecogStatus(patient); - - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).isEqualTo("OS.Strahlentherapie"); - } - - @Test - void testShouldReturnListOfEcogStatusWithDate() { - doAnswer(invocationOnMock -> { - var disease = new Disease(onkostarApi); - disease.setId(1); - return List.of(disease); - }).when(this.onkostarApi).getDiseasesByPatientId(anyInt()); - - doAnswer(invocationOnMock -> { - var procedure1 = new Procedure(onkostarApi); - procedure1.setId(1); - procedure1.setFormName("OS.Strahlentherapie"); - procedure1.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); - procedure1.setEditState(ProcedureEditStateType.COMPLETED); - procedure1.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - var procedure2 = new Procedure(onkostarApi); - procedure2.setId(2); - procedure2.setFormName("OS.Strahlentherapie"); - procedure2.setStartDate(Date.from(Instant.parse("2023-07-12T06:00:00Z"))); - procedure2.setEditState(ProcedureEditStateType.COMPLETED); - procedure2.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 2)); - return List.of(procedure1, procedure2); - }).when(this.onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var actual = service.ecogStatus(patient); - - assertThat(actual) - .isNotNull() - .isExactlyInstanceOf(ArrayList.class) - .hasSize(2); - } + private IOnkostarApi onkostarApi; + + private SettingsService settingsService; + + private DefaultStrahlentherapieService service; + + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi, @Mock SettingsService settingsService) { + this.onkostarApi = onkostarApi; + this.settingsService = settingsService; + this.service = new DefaultStrahlentherapieService(onkostarApi, settingsService); + } + + @Test + void testShouldRequestProceduresWithDefaultFormName() { + when(this.settingsService.getSetting(anyString())).thenReturn(Optional.empty()); + + doAnswer( + invocationOnMock -> { + var procedure = new Procedure(onkostarApi); + procedure.setId(1); + procedure.setFormName("OS.Strahlentherapie"); + procedure.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); + procedure.setEditState(ProcedureEditStateType.COMPLETED); + procedure.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + return Lists.list(procedure); + }) + .when(this.onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + doAnswer( + invocationOnMock -> { + var disease = new Disease(onkostarApi); + disease.setId(1); + disease.setPatientId(123); + return Lists.list(disease); + }) + .when(this.onkostarApi) + .getDiseasesByPatientId(anyInt()); + + var patient = new Patient(onkostarApi); + patient.setId(123); + + service.ecogStatus(patient); + + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).isEqualTo("OS.Strahlentherapie"); + } + + @Test + void testShouldReturnListOfEcogStatusWithDate() { + doAnswer( + invocationOnMock -> { + var disease = new Disease(onkostarApi); + disease.setId(1); + return List.of(disease); + }) + .when(this.onkostarApi) + .getDiseasesByPatientId(anyInt()); + + doAnswer( + invocationOnMock -> { + var procedure1 = new Procedure(onkostarApi); + procedure1.setId(1); + procedure1.setFormName("OS.Strahlentherapie"); + procedure1.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); + procedure1.setEditState(ProcedureEditStateType.COMPLETED); + procedure1.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + var procedure2 = new Procedure(onkostarApi); + procedure2.setId(2); + procedure2.setFormName("OS.Strahlentherapie"); + procedure2.setStartDate(Date.from(Instant.parse("2023-07-12T06:00:00Z"))); + procedure2.setEditState(ProcedureEditStateType.COMPLETED); + procedure2.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 2)); + return List.of(procedure1, procedure2); + }) + .when(this.onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var actual = service.ecogStatus(patient); + + assertThat(actual).isNotNull().isExactlyInstanceOf(ArrayList.class).hasSize(2); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/systemtherapie/DefaultSystemtherapieServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/systemtherapie/DefaultSystemtherapieServiceTest.java index e8d474b..05cd535 100644 --- a/src/test/java/dev/dnpm/oshelper/services/systemtherapie/DefaultSystemtherapieServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/systemtherapie/DefaultSystemtherapieServiceTest.java @@ -19,8 +19,13 @@ package dev.dnpm.oshelper.services.systemtherapie; -import dev.dnpm.oshelper.services.SettingsService; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.*; +import dev.dnpm.oshelper.services.SettingsService; +import java.time.Instant; +import java.util.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -30,121 +35,126 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.util.*; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class DefaultSystemtherapieServiceTest { - private IOnkostarApi onkostarApi; - - private SettingsService settingsService; - - private DefaultSystemtherapieService service; - - @BeforeEach - void setup(@Mock IOnkostarApi onkostarApi, @Mock SettingsService settingsService) { - this.onkostarApi = onkostarApi; - this.settingsService = settingsService; - this.service = new DefaultSystemtherapieService(onkostarApi, settingsService); - } - - private static Set>> expectedMapperMappings() { - return Map.ofEntries(Map.entry("OS.Systemische Therapie", OsSystemischeTherapieToProzedurwerteMapper.class), Map.entry("OS.Systemische Therapie.VarianteUKW", OsSystemischeTherapieToProzedurwerteMapper.class)).entrySet(); - } - - @ParameterizedTest - @MethodSource("expectedMapperMappings") - void testShouldMapFormNameToMapper(Map.Entry> expectedMapping) { - var procedure = new Procedure(onkostarApi); - procedure.setFormName(expectedMapping.getKey()); - - var actual = service.prozedurToProzedurwerteMapper(procedure); - - assertThat(actual).isExactlyInstanceOf(expectedMapping.getValue()); - } - - private static List formnameSetting() { - return List.of("OS.Systemische Therapie", "OS.Systemische Therapie.VarianteUKW"); - } - - @ParameterizedTest - @MethodSource("formnameSetting") - void testShouldRequestProceduresWithExpectedFormName(String expectedFormName) { - when(this.settingsService.getSetting(anyString())).thenReturn(Optional.of(expectedFormName)); - when(this.onkostarApi.getProceduresForDiseaseByForm(anyInt(), anyString())).thenReturn(List.of()); - - service.getSystemischeTherapienFromDiagnose(123); - - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).isEqualTo(expectedFormName); - } - - @Test - void testShouldRequestProceduresWithDefaultFormName() { - when(this.settingsService.getSetting(anyString())).thenReturn(Optional.empty()); - when(this.onkostarApi.getProceduresForDiseaseByForm(anyInt(), anyString())).thenReturn(List.of()); - - service.getSystemischeTherapienFromDiagnose(123); - - var argumentCaptor = ArgumentCaptor.forClass(String.class); - verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); - assertThat(argumentCaptor.getValue()).isEqualTo("OS.Systemische Therapie"); - } - - @Test - void testShouldReturnSystemischeTherapienFromDiagnose() { - doAnswer(invocationOnMock -> { - var procedure = new Procedure(onkostarApi); - procedure.setFormName("OS.Systemische Therapie"); - return List.of(procedure); - }).when(this.onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - var actual = service.getSystemischeTherapienFromDiagnose(1); - - assertThat(actual) - .isNotNull() - .isExactlyInstanceOf(ArrayList.class) - .hasSize(1); - } - - @Test - void testShouldReturnListOfEcogStatusWithDate() { - doAnswer(invocationOnMock -> { - var disease = new Disease(onkostarApi); - disease.setId(1); - return List.of(disease); - }).when(this.onkostarApi).getDiseasesByPatientId(anyInt()); - - doAnswer(invocationOnMock -> { - var procedure1 = new Procedure(onkostarApi); - procedure1.setId(1); - procedure1.setFormName("OS.Systemische Therapie"); - procedure1.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); - procedure1.setEditState(ProcedureEditStateType.COMPLETED); - procedure1.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); - - var procedure2 = new Procedure(onkostarApi); - procedure2.setId(2); - procedure2.setFormName("OS.Systemische Therapie"); - procedure2.setStartDate(Date.from(Instant.parse("2023-07-12T06:00:00Z"))); - procedure2.setEditState(ProcedureEditStateType.COMPLETED); - procedure2.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 2)); - return List.of(procedure1, procedure2); - }).when(this.onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - var patient = new Patient(onkostarApi); - patient.setId(1); - - var actual = service.ecogStatus(patient); - - assertThat(actual) - .isNotNull() - .isExactlyInstanceOf(ArrayList.class) - .hasSize(2); - } + private IOnkostarApi onkostarApi; + + private SettingsService settingsService; + + private DefaultSystemtherapieService service; + + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi, @Mock SettingsService settingsService) { + this.onkostarApi = onkostarApi; + this.settingsService = settingsService; + this.service = new DefaultSystemtherapieService(onkostarApi, settingsService); + } + + private static Set>> + expectedMapperMappings() { + return Map.ofEntries( + Map.entry("OS.Systemische Therapie", OsSystemischeTherapieToProzedurwerteMapper.class), + Map.entry( + "OS.Systemische Therapie.VarianteUKW", + OsSystemischeTherapieToProzedurwerteMapper.class)) + .entrySet(); + } + + @ParameterizedTest + @MethodSource("expectedMapperMappings") + void testShouldMapFormNameToMapper(Map.Entry> expectedMapping) { + var procedure = new Procedure(onkostarApi); + procedure.setFormName(expectedMapping.getKey()); + + var actual = service.prozedurToProzedurwerteMapper(procedure); + + assertThat(actual).isExactlyInstanceOf(expectedMapping.getValue()); + } + + private static List formnameSetting() { + return List.of("OS.Systemische Therapie", "OS.Systemische Therapie.VarianteUKW"); + } + + @ParameterizedTest + @MethodSource("formnameSetting") + void testShouldRequestProceduresWithExpectedFormName(String expectedFormName) { + when(this.settingsService.getSetting(anyString())).thenReturn(Optional.of(expectedFormName)); + when(this.onkostarApi.getProceduresForDiseaseByForm(anyInt(), anyString())) + .thenReturn(List.of()); + + service.getSystemischeTherapienFromDiagnose(123); + + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).isEqualTo(expectedFormName); + } + + @Test + void testShouldRequestProceduresWithDefaultFormName() { + when(this.settingsService.getSetting(anyString())).thenReturn(Optional.empty()); + when(this.onkostarApi.getProceduresForDiseaseByForm(anyInt(), anyString())) + .thenReturn(List.of()); + + service.getSystemischeTherapienFromDiagnose(123); + + var argumentCaptor = ArgumentCaptor.forClass(String.class); + verify(onkostarApi, times(1)).getProceduresForDiseaseByForm(anyInt(), argumentCaptor.capture()); + assertThat(argumentCaptor.getValue()).isEqualTo("OS.Systemische Therapie"); + } + + @Test + void testShouldReturnSystemischeTherapienFromDiagnose() { + doAnswer( + invocationOnMock -> { + var procedure = new Procedure(onkostarApi); + procedure.setFormName("OS.Systemische Therapie"); + return List.of(procedure); + }) + .when(this.onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + var actual = service.getSystemischeTherapienFromDiagnose(1); + + assertThat(actual).isNotNull().isExactlyInstanceOf(ArrayList.class).hasSize(1); + } + + @Test + void testShouldReturnListOfEcogStatusWithDate() { + doAnswer( + invocationOnMock -> { + var disease = new Disease(onkostarApi); + disease.setId(1); + return List.of(disease); + }) + .when(this.onkostarApi) + .getDiseasesByPatientId(anyInt()); + + doAnswer( + invocationOnMock -> { + var procedure1 = new Procedure(onkostarApi); + procedure1.setId(1); + procedure1.setFormName("OS.Systemische Therapie"); + procedure1.setStartDate(Date.from(Instant.parse("2023-07-01T06:00:00Z"))); + procedure1.setEditState(ProcedureEditStateType.COMPLETED); + procedure1.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 1)); + + var procedure2 = new Procedure(onkostarApi); + procedure2.setId(2); + procedure2.setFormName("OS.Systemische Therapie"); + procedure2.setStartDate(Date.from(Instant.parse("2023-07-12T06:00:00Z"))); + procedure2.setEditState(ProcedureEditStateType.COMPLETED); + procedure2.setValue("ECOGvorTherapie", new Item("ECOGvorTherapie", 2)); + return List.of(procedure1, procedure2); + }) + .when(this.onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + var patient = new Patient(onkostarApi); + patient.setId(1); + + var actual = service.ecogStatus(patient); + + assertThat(actual).isNotNull().isExactlyInstanceOf(ArrayList.class).hasSize(2); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/systemtherapie/ProzedurToProzedurwerteMapperTest.java b/src/test/java/dev/dnpm/oshelper/services/systemtherapie/ProzedurToProzedurwerteMapperTest.java index 6c7c532..085834f 100644 --- a/src/test/java/dev/dnpm/oshelper/services/systemtherapie/ProzedurToProzedurwerteMapperTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/systemtherapie/ProzedurToProzedurwerteMapperTest.java @@ -19,72 +19,72 @@ package dev.dnpm.oshelper.services.systemtherapie; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; +import java.sql.Date; +import java.time.Instant; +import java.util.ArrayList; +import java.util.Map; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.sql.Date; -import java.time.Instant; -import java.util.ArrayList; -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; - @ExtendWith(MockitoExtension.class) class ProzedurToProzedurwerteMapperTest { - private IOnkostarApi onkostarApi; - - private OsSystemischeTherapieToProzedurwerteMapper mapper; + private IOnkostarApi onkostarApi; - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi - ) { - this.onkostarApi = onkostarApi; - this.mapper = new OsSystemischeTherapieToProzedurwerteMapper(); - } + private OsSystemischeTherapieToProzedurwerteMapper mapper; - @Test - void testShouldReturnSystemischeTherapienFromDiagnose() { - var procedure = new Procedure(onkostarApi); - procedure.setFormName("OS.Systemische Therapie"); - procedure.setValue("Beginn", new Item("Beginn", Date.from(Instant.parse("2023-01-01T00:00:00Z")))); - procedure.setValue("Ende", new Item("Ende", Date.from(Instant.parse("2023-01-31T00:00:00Z")))); - procedure.setValue("Beendigung", new Item("Beendigungsstatus", "E")); - procedure.setValue("Ergebnis", new Item("Ergebnis", "T")); + @BeforeEach + void setup(@Mock IOnkostarApi onkostarApi) { + this.onkostarApi = onkostarApi; + this.mapper = new OsSystemischeTherapieToProzedurwerteMapper(); + } - var substanzen = new ArrayList<>(); - substanzen.add(Map.of( - "Substanz", "Testsubstanz", - "Substanz_shortDescription", "Testsubstanz" - )); - substanzen.add(Map.of( - "Substanz", "L01AA01", - "Substanz_shortDescription", "cyclophosphamide" - )); - procedure.setValue("SubstanzenList", new Item("SubstanzenList", substanzen)); + @Test + void testShouldReturnSystemischeTherapienFromDiagnose() { + var procedure = new Procedure(onkostarApi); + procedure.setFormName("OS.Systemische Therapie"); + procedure.setValue( + "Beginn", new Item("Beginn", Date.from(Instant.parse("2023-01-01T00:00:00Z")))); + procedure.setValue("Ende", new Item("Ende", Date.from(Instant.parse("2023-01-31T00:00:00Z")))); + procedure.setValue("Beendigung", new Item("Beendigungsstatus", "E")); + procedure.setValue("Ergebnis", new Item("Ergebnis", "T")); - var actual = mapper.apply(procedure); + var substanzen = new ArrayList<>(); + substanzen.add( + Map.of( + "Substanz", "Testsubstanz", + "Substanz_shortDescription", "Testsubstanz")); + substanzen.add( + Map.of( + "Substanz", "L01AA01", + "Substanz_shortDescription", "cyclophosphamide")); + procedure.setValue("SubstanzenList", new Item("SubstanzenList", substanzen)); - assertThat(actual).isPresent(); + var actual = mapper.apply(procedure); - assertThat(actual.get()).containsEntry("Beginn", Date.from(Instant.parse("2023-01-01T00:00:00Z")).toString()); - assertThat(actual.get()).containsEntry("Ende", Date.from(Instant.parse("2023-01-31T00:00:00Z")).toString()); - assertThat(actual.get()).containsEntry("Beendigung", "E"); - assertThat(actual.get()).containsEntry("Ergebnis", "T"); - assertThat(actual.get()).containsEntry("Wirkstoffe", "Testsubstanz, cyclophosphamide"); - assertThat(actual.get()).containsEntry("WirkstoffCodes", - "[" + - "{\"system\":\"other\",\"code\":\"Testsubstanz\",\"substance\":\"Testsubstanz\"}," + - "{\"system\":\"ATC\",\"code\":\"L01AA01\",\"substance\":\"cyclophosphamide\"}" + - "]" - ); - } + assertThat(actual).isPresent(); + assertThat(actual.get()) + .containsEntry("Beginn", Date.from(Instant.parse("2023-01-01T00:00:00Z")).toString()); + assertThat(actual.get()) + .containsEntry("Ende", Date.from(Instant.parse("2023-01-31T00:00:00Z")).toString()); + assertThat(actual.get()).containsEntry("Beendigung", "E"); + assertThat(actual.get()).containsEntry("Ergebnis", "T"); + assertThat(actual.get()).containsEntry("Wirkstoffe", "Testsubstanz, cyclophosphamide"); + assertThat(actual.get()) + .containsEntry( + "WirkstoffCodes", + "[" + + "{\"system\":\"other\",\"code\":\"Testsubstanz\",\"substance\":\"Testsubstanz\"}," + + "{\"system\":\"ATC\",\"code\":\"L01AA01\",\"substance\":\"cyclophosphamide\"}" + + "]"); + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/therapieplan/DefaultTherapieplanServiceTest.java b/src/test/java/dev/dnpm/oshelper/services/therapieplan/DefaultTherapieplanServiceTest.java index 18865a8..1d68e08 100644 --- a/src/test/java/dev/dnpm/oshelper/services/therapieplan/DefaultTherapieplanServiceTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/therapieplan/DefaultTherapieplanServiceTest.java @@ -19,11 +19,17 @@ package dev.dnpm.oshelper.services.therapieplan; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.*; + import de.itc.onkostar.api.IOnkostarApi; import de.itc.onkostar.api.Item; import de.itc.onkostar.api.Procedure; import de.itc.onkostar.api.constants.JaNeinUnbekannt; import dev.dnpm.oshelper.services.FormService; +import java.time.Instant; +import java.util.Date; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -31,158 +37,166 @@ import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import java.time.Instant; -import java.util.Date; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class DefaultTherapieplanServiceTest { - private IOnkostarApi onkostarApi; - - private TherapieplanService service; - - @BeforeEach - void setUp( - @Mock IOnkostarApi onkostarApi, - @Mock FormService formService - ) { - this.onkostarApi = onkostarApi; - this.service = new DefaultTherapieplanService(onkostarApi, formService); - } - - @Test - void shouldNotUpdateSubformsOrSectionsIfMultipleMtbConfiguration() throws Exception { - this.service.updateRequiredMtbEntries(new Procedure(onkostarApi)); - verify(onkostarApi, never()).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void shouldNotUpdateSectionsIfSectionsNotEnabled() throws Exception { - var testProcedure = baseProcedure(onkostarApi); - - // Keine humangenetische Beratung und keine Reevaluation empfohlen - testProcedure.setValue("humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.NEIN.getCode())); - testProcedure.setValue("reevaluation", new Item("reevaluation", JaNeinUnbekannt.NEIN.getCode())); - - this.service.updateRequiredMtbEntries(testProcedure); - - verify(onkostarApi, never()).saveProcedure(any(Procedure.class), anyBoolean()); - } - - @Test - void shouldUpdateSectionsIfNoReevaluation() throws Exception { - var testProcedure = baseProcedure(onkostarApi); - - // Humangenetische Beratung aber keine Reevaluation - testProcedure.setValue("humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.JA.getCode())); - testProcedure.setValue("humangenberbegruendung", new Item("humangen_ber_begruendung", "Das ist die Begründung")); - testProcedure.setValue("reevaluation", new Item("reevaluation", JaNeinUnbekannt.NEIN.getCode())); - - this.service.updateRequiredMtbEntries(testProcedure); - - var captor = ArgumentCaptor.forClass(Procedure.class); - verify(onkostarApi, times(1)).saveProcedure(captor.capture(), anyBoolean()); - - var capturedProcedure = captor.getValue(); - - assertThat(capturedProcedure.getValue("reftkreevaluation")).isNull(); - assertThat(capturedProcedure.getValue("datumtkreevaluation")).isNull(); - - assertThat(capturedProcedure.getValue("reftkhumangenber")).isNotNull(); - assertThat(capturedProcedure.getValue("reftkhumangenber").getInt()).isEqualTo(procedureId); - assertThat(capturedProcedure.getValue("datumtkhumangenber")).isNotNull(); - assertThat(capturedProcedure.getValue("datumtkhumangenber").getDate()).isEqualTo(testDate); - } - - @Test - void shouldUpdateSectionsIfNoHumanGenConsultation() throws Exception { - var testProcedure = baseProcedure(onkostarApi); - - // Humangenetische Beratung aber keine Reevaluation - testProcedure.setValue("humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.NEIN.getCode())); - testProcedure.setValue("reevaluation", new Item("reevaluation", JaNeinUnbekannt.JA.getCode())); - - this.service.updateRequiredMtbEntries(testProcedure); - - var captor = ArgumentCaptor.forClass(Procedure.class); - verify(onkostarApi, times(1)).saveProcedure(captor.capture(), anyBoolean()); - - var capturedProcedure = captor.getValue(); - - assertThat(capturedProcedure.getValue("reftkhumangenber")).isNull(); - assertThat(capturedProcedure.getValue("datumtkhumangenber")).isNull(); - - assertThat(capturedProcedure.getValue("reftkreevaluation")).isNotNull(); - assertThat(capturedProcedure.getValue("reftkreevaluation").getInt()).isEqualTo(procedureId); - assertThat(capturedProcedure.getValue("datumtkreevaluation")).isNotNull(); - assertThat(capturedProcedure.getValue("datumtkreevaluation").getDate()).isEqualTo(testDate); - } - - @Test - void shouldFindFollowUps() { - doAnswer(invocationOnMock -> { - var testProcedure = baseProcedure(onkostarApi); - testProcedure.setId(procedureId); - testProcedure.setFormName("DNPM UF Einzelempfehlung"); - testProcedure.addDiseaseId(123); - return testProcedure; - }).when(onkostarApi).getProcedure(anyInt()); - - doAnswer(invocationOnMock -> { - var diseaseId = invocationOnMock.getArgument(0, Integer.class); - var formName = invocationOnMock.getArgument(1, String.class); - var procedure = baseProcedure(onkostarApi); - procedure.addDiseaseId(diseaseId); - procedure.setFormName(formName); - procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", procedureId)); - return List.of(procedure); - }).when(onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - var followUps = this.service.findReferencedFollowUpsForSubform(1); - - assertThat(followUps).hasSize(1) - .allSatisfy(procedure -> assertThat(procedure.getFormName()).isEqualTo("DNPM FollowUp")); - } - - @Test - void shouldFindFollowUpsById() { - var testProcedure = baseProcedure(onkostarApi); - testProcedure.setId(procedureId); - testProcedure.setFormName("DNPM UF Einzelempfehlung"); - testProcedure.addDiseaseId(123); - - doAnswer(invocationOnMock -> { - var diseaseId = invocationOnMock.getArgument(0, Integer.class); - var formName = invocationOnMock.getArgument(1, String.class); - var procedure = baseProcedure(onkostarApi); - procedure.addDiseaseId(diseaseId); - procedure.setFormName(formName); - procedure.setValue("LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", procedureId)); - return List.of(procedure); - }).when(onkostarApi).getProceduresForDiseaseByForm(anyInt(), anyString()); - - var followUps = this.service.findReferencedFollowUpsForSubform(testProcedure); - - assertThat(followUps).hasSize(1) - .allSatisfy(procedure -> assertThat(procedure.getFormName()).isEqualTo("DNPM FollowUp")); - } - - private static final int procedureId = 1234; - private static final Date testDate = Date.from(Instant.parse("2023-03-15T09:43:00Z")); - - private Procedure baseProcedure(final IOnkostarApi onkostarApi) { - var testProcedure = new Procedure(onkostarApi); - testProcedure.setId(1000); - - // Setzen MTB Referenz und Datum MTB - testProcedure.setValue("referstemtb", new Item("ref_tumorkonferenz", procedureId)); - testProcedure.setValue("datum", new Item("datum", testDate)); - - return testProcedure; - } - + private IOnkostarApi onkostarApi; + + private TherapieplanService service; + + @BeforeEach + void setUp(@Mock IOnkostarApi onkostarApi, @Mock FormService formService) { + this.onkostarApi = onkostarApi; + this.service = new DefaultTherapieplanService(onkostarApi, formService); + } + + @Test + void shouldNotUpdateSubformsOrSectionsIfMultipleMtbConfiguration() throws Exception { + this.service.updateRequiredMtbEntries(new Procedure(onkostarApi)); + verify(onkostarApi, never()).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void shouldNotUpdateSectionsIfSectionsNotEnabled() throws Exception { + var testProcedure = baseProcedure(onkostarApi); + + // Keine humangenetische Beratung und keine Reevaluation empfohlen + testProcedure.setValue( + "humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.NEIN.getCode())); + testProcedure.setValue( + "reevaluation", new Item("reevaluation", JaNeinUnbekannt.NEIN.getCode())); + + this.service.updateRequiredMtbEntries(testProcedure); + + verify(onkostarApi, never()).saveProcedure(any(Procedure.class), anyBoolean()); + } + + @Test + void shouldUpdateSectionsIfNoReevaluation() throws Exception { + var testProcedure = baseProcedure(onkostarApi); + + // Humangenetische Beratung aber keine Reevaluation + testProcedure.setValue( + "humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.JA.getCode())); + testProcedure.setValue( + "humangenberbegruendung", new Item("humangen_ber_begruendung", "Das ist die Begründung")); + testProcedure.setValue( + "reevaluation", new Item("reevaluation", JaNeinUnbekannt.NEIN.getCode())); + + this.service.updateRequiredMtbEntries(testProcedure); + + var captor = ArgumentCaptor.forClass(Procedure.class); + verify(onkostarApi, times(1)).saveProcedure(captor.capture(), anyBoolean()); + + var capturedProcedure = captor.getValue(); + + assertThat(capturedProcedure.getValue("reftkreevaluation")).isNull(); + assertThat(capturedProcedure.getValue("datumtkreevaluation")).isNull(); + + assertThat(capturedProcedure.getValue("reftkhumangenber")).isNotNull(); + assertThat(capturedProcedure.getValue("reftkhumangenber").getInt()).isEqualTo(procedureId); + assertThat(capturedProcedure.getValue("datumtkhumangenber")).isNotNull(); + assertThat(capturedProcedure.getValue("datumtkhumangenber").getDate()).isEqualTo(testDate); + } + + @Test + void shouldUpdateSectionsIfNoHumanGenConsultation() throws Exception { + var testProcedure = baseProcedure(onkostarApi); + + // Humangenetische Beratung aber keine Reevaluation + testProcedure.setValue( + "humangenberatung", new Item("humangen_beratung", JaNeinUnbekannt.NEIN.getCode())); + testProcedure.setValue("reevaluation", new Item("reevaluation", JaNeinUnbekannt.JA.getCode())); + + this.service.updateRequiredMtbEntries(testProcedure); + + var captor = ArgumentCaptor.forClass(Procedure.class); + verify(onkostarApi, times(1)).saveProcedure(captor.capture(), anyBoolean()); + + var capturedProcedure = captor.getValue(); + + assertThat(capturedProcedure.getValue("reftkhumangenber")).isNull(); + assertThat(capturedProcedure.getValue("datumtkhumangenber")).isNull(); + + assertThat(capturedProcedure.getValue("reftkreevaluation")).isNotNull(); + assertThat(capturedProcedure.getValue("reftkreevaluation").getInt()).isEqualTo(procedureId); + assertThat(capturedProcedure.getValue("datumtkreevaluation")).isNotNull(); + assertThat(capturedProcedure.getValue("datumtkreevaluation").getDate()).isEqualTo(testDate); + } + + @Test + void shouldFindFollowUps() { + doAnswer( + invocationOnMock -> { + var testProcedure = baseProcedure(onkostarApi); + testProcedure.setId(procedureId); + testProcedure.setFormName("DNPM UF Einzelempfehlung"); + testProcedure.addDiseaseId(123); + return testProcedure; + }) + .when(onkostarApi) + .getProcedure(anyInt()); + + doAnswer( + invocationOnMock -> { + var diseaseId = invocationOnMock.getArgument(0, Integer.class); + var formName = invocationOnMock.getArgument(1, String.class); + var procedure = baseProcedure(onkostarApi); + procedure.addDiseaseId(diseaseId); + procedure.setFormName(formName); + procedure.setValue( + "LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", procedureId)); + return List.of(procedure); + }) + .when(onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + var followUps = this.service.findReferencedFollowUpsForSubform(1); + + assertThat(followUps) + .hasSize(1) + .allSatisfy(procedure -> assertThat(procedure.getFormName()).isEqualTo("DNPM FollowUp")); + } + + @Test + void shouldFindFollowUpsById() { + var testProcedure = baseProcedure(onkostarApi); + testProcedure.setId(procedureId); + testProcedure.setFormName("DNPM UF Einzelempfehlung"); + testProcedure.addDiseaseId(123); + + doAnswer( + invocationOnMock -> { + var diseaseId = invocationOnMock.getArgument(0, Integer.class); + var formName = invocationOnMock.getArgument(1, String.class); + var procedure = baseProcedure(onkostarApi); + procedure.addDiseaseId(diseaseId); + procedure.setFormName(formName); + procedure.setValue( + "LinkTherapieempfehlung", new Item("LinkTherapieempfehlung", procedureId)); + return List.of(procedure); + }) + .when(onkostarApi) + .getProceduresForDiseaseByForm(anyInt(), anyString()); + + var followUps = this.service.findReferencedFollowUpsForSubform(testProcedure); + + assertThat(followUps) + .hasSize(1) + .allSatisfy(procedure -> assertThat(procedure.getFormName()).isEqualTo("DNPM FollowUp")); + } + + private static final int procedureId = 1234; + private static final Date testDate = Date.from(Instant.parse("2023-03-15T09:43:00Z")); + + private Procedure baseProcedure(final IOnkostarApi onkostarApi) { + var testProcedure = new Procedure(onkostarApi); + testProcedure.setId(1000); + + // Setzen MTB Referenz und Datum MTB + testProcedure.setValue("referstemtb", new Item("ref_tumorkonferenz", procedureId)); + testProcedure.setValue("datum", new Item("datum", testDate)); + + return testProcedure; + } } diff --git a/src/test/java/dev/dnpm/oshelper/services/therapieplan/TherapieplanServiceFactoryTest.java b/src/test/java/dev/dnpm/oshelper/services/therapieplan/TherapieplanServiceFactoryTest.java index 7c176bb..c6db22a 100644 --- a/src/test/java/dev/dnpm/oshelper/services/therapieplan/TherapieplanServiceFactoryTest.java +++ b/src/test/java/dev/dnpm/oshelper/services/therapieplan/TherapieplanServiceFactoryTest.java @@ -19,6 +19,8 @@ package dev.dnpm.oshelper.services.therapieplan; +import static org.assertj.core.api.Assertions.assertThat; + import de.itc.onkostar.api.IOnkostarApi; import dev.dnpm.oshelper.services.FormService; import dev.dnpm.oshelper.services.SettingsService; @@ -28,28 +30,26 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; - @ExtendWith(MockitoExtension.class) class TherapieplanServiceFactoryTest { - private SettingsService settingsService; - - private TherapieplanServiceFactory therapieplanServiceFactory; - - @BeforeEach - void setup( - @Mock IOnkostarApi onkostarApi, - @Mock SettingsService settingsService, - @Mock FormService formService - ) { - this.settingsService = settingsService; - this.therapieplanServiceFactory = new TherapieplanServiceFactory(onkostarApi, settingsService, formService); - } - - @Test - void testShouldAlwaysReturnDefaultTherapieplanService() { - var actual = this.therapieplanServiceFactory.currentUsableInstance(); - assertThat(actual).isInstanceOf(DefaultTherapieplanService.class); - } + private SettingsService settingsService; + + private TherapieplanServiceFactory therapieplanServiceFactory; + + @BeforeEach + void setup( + @Mock IOnkostarApi onkostarApi, + @Mock SettingsService settingsService, + @Mock FormService formService) { + this.settingsService = settingsService; + this.therapieplanServiceFactory = + new TherapieplanServiceFactory(onkostarApi, settingsService, formService); + } + + @Test + void testShouldAlwaysReturnDefaultTherapieplanService() { + var actual = this.therapieplanServiceFactory.currentUsableInstance(); + assertThat(actual).isInstanceOf(DefaultTherapieplanService.class); + } } -- cgit v1.2.3