build: apply Spotless plugin (#293)

5 files changed, 422 insertions, 418 deletions

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<String, Object> input = Map.of("value1", 1, "valueA", "A", "valueTrue", true);
-
-    private static Set<TestTypeData> 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<String, Object> input = Map.of("value1", 1, "valueA", "A", "valueTrue", true);
+
+  private static Set<TestTypeData> 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> 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> 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<String, Object>();
-        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<String, Object>();
+    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();
+  }
 }