chore: use spotless for kotlin code (#191)

15 files changed, 1143 insertions, 1200 deletions

diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/AbstractTestcontainerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/AbstractTestcontainerTest.kt
index 13b57d0..136691e 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/AbstractTestcontainerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/AbstractTestcontainerTest.kt
@@ -25,13 +25,13 @@ import org.testcontainers.containers.PostgreSQLContainer
 import org.testcontainers.junit.jupiter.Container
 
 abstract class AbstractTestcontainerTest {
-
     companion object {
         @Container
-        val dbContainer = CustomPostgreSQLContainer("postgres:10-alpine")
-            .withDatabaseName("test")
-            .withUsername("test")
-            .withPassword("test") ?: throw RuntimeException("Failed to create testcontainer!")
+        val dbContainer =
+            CustomPostgreSQLContainer("postgres:10-alpine")
+                .withDatabaseName("test")
+                .withUsername("test")
+                .withPassword("test") ?: throw RuntimeException("Failed to create testcontainer!")
 
         @DynamicPropertySource
         @JvmStatic
@@ -41,11 +41,12 @@ abstract class AbstractTestcontainerTest {
             registry.add("spring.datasource.password", dbContainer::getPassword)
         }
     }
-
 }
 
-class CustomPostgreSQLContainer(dockerImageName: String) : PostgreSQLContainer<CustomPostgreSQLContainer>(dockerImageName) {
+class CustomPostgreSQLContainer(
+    dockerImageName: String,
+) : PostgreSQLContainer<CustomPostgreSQLContainer>(dockerImageName) {
     override fun stop() {
         // Keep Testcontainer alive until JVM destroys it
     }
-}
\ No newline at end of file
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorApplicationTests.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorApplicationTests.kt
index 1206c99..7826702 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorApplicationTests.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorApplicationTests.kt
@@ -48,98 +48,95 @@ import org.testcontainers.junit.jupiter.Testcontainers
 @SpringBootTest
 @MockitoBean(types = [MtbFileSender::class])
 @TestPropertySource(
-    properties = [
-        "app.rest.uri=http://example.com",
-        "app.pseudonymize.generator=buildin",
-        "app.consent.service=none"
-    ]
+    properties =
+        [
+            "app.rest.uri=http://example.com",
+            "app.pseudonymize.generator=buildin",
+            "app.consent.service=none",
+        ]
 )
 class EtlProcessorApplicationTests : AbstractTestcontainerTest() {
 
-    @Test
-    fun contextLoadsIfMtbFileSenderConfigured(@Autowired context: ApplicationContext) {
-        // Simply check bean configuration
-        assertThat(context).isNotNull
-    }
+  @Test
+  fun contextLoadsIfMtbFileSenderConfigured(@Autowired context: ApplicationContext) {
+    // Simply check bean configuration
+    assertThat(context).isNotNull
+  }
 
-    @Nested
-    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
-    @AutoConfigureMockMvc
-    @TestPropertySource(
-        properties = [
-            "app.pseudonymize.generator=buildin",
-            "app.consent.service=none",
-            "app.transformations[0].path=diagnoses[*].code.version",
-            "app.transformations[0].from=2013",
-            "app.transformations[0].to=2014",
-        ]
-    )
-    inner class TransformationTest {
+  @Nested
+  @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
+  @AutoConfigureMockMvc
+  @TestPropertySource(
+      properties =
+          [
+              "app.pseudonymize.generator=buildin",
+              "app.consent.service=none",
+              "app.transformations[0].path=diagnoses[*].code.version",
+              "app.transformations[0].from=2013",
+              "app.transformations[0].to=2014",
+          ]
+  )
+  inner class TransformationTest {
 
-        @MockitoBean
-        private lateinit var mtbFileSender: MtbFileSender
+    @MockitoBean private lateinit var mtbFileSender: MtbFileSender
 
-        @Autowired
-        private lateinit var mockMvc: MockMvc
+    @Autowired private lateinit var mockMvc: MockMvc
 
-        @Autowired
-        private lateinit var objectMapper: ObjectMapper
+    @Autowired private lateinit var objectMapper: ObjectMapper
 
-        @BeforeEach
-        fun setup(@Autowired requestRepository: RequestRepository) {
-            requestRepository.deleteAll()
-        }
+    @BeforeEach
+    fun setup(@Autowired requestRepository: RequestRepository) {
+      requestRepository.deleteAll()
+    }
 
-        @Test
-        fun mtbFileIsTransformed() {
-            doAnswer {
-                MtbFileSender.Response(RequestStatus.SUCCESS)
-            }.whenever(mtbFileSender).send(any<DnpmV2MtbFileRequest>())
+    @Test
+    fun mtbFileIsTransformed() {
+      doAnswer { MtbFileSender.Response(RequestStatus.SUCCESS) }
+          .whenever(mtbFileSender)
+          .send(any<DnpmV2MtbFileRequest>())
 
-            val mtbFile = Mtb.builder()
-                .patient(
-                    Patient.builder()
-                        .id("TEST_12345678")
-                        .build()
-                )
-                .metadata(
-                    MvhMetadata
-                        .builder()
-                        .modelProjectConsent(
-                            ModelProjectConsent
-                                .builder()
-                                .provisions(
-                                    listOf(Provision.builder().type(ConsentProvision.PERMIT).purpose(ModelProjectConsentPurpose.SEQUENCING).build())
-                                ).build()
-                        )
-                        .build()
-                )
-                .diagnoses(
-                    listOf(
-                        MtbDiagnosis.builder()
-                            .id("1234")
-                            .patient(Reference.builder().id("TEST_12345678").build())
-                            .code(Coding.builder().code("F79.9").version("2013").build())
-                            .build(),
-                    )
-                )
-                .build()
+      val mtbFile =
+          Mtb.builder()
+              .patient(Patient.builder().id("TEST_12345678").build())
+              .metadata(
+                  MvhMetadata.builder()
+                      .modelProjectConsent(
+                          ModelProjectConsent.builder()
+                              .provisions(
+                                  listOf(
+                                      Provision.builder()
+                                          .type(ConsentProvision.PERMIT)
+                                          .purpose(ModelProjectConsentPurpose.SEQUENCING)
+                                          .build()
+                                  )
+                              )
+                              .build()
+                      )
+                      .build()
+              )
+              .diagnoses(
+                  listOf(
+                      MtbDiagnosis.builder()
+                          .id("1234")
+                          .patient(Reference.builder().id("TEST_12345678").build())
+                          .code(Coding.builder().code("F79.9").version("2013").build())
+                          .build(),
+                  )
+              )
+              .build()
 
-            mockMvc.post("/mtbfile") {
-                content = objectMapper.writeValueAsString(mtbFile)
-                contentType = MediaType.APPLICATION_JSON
-            }.andExpect {
-                status {
-                    isAccepted()
-                }
-            }
+      mockMvc
+          .post("/mtbfile") {
+            content = objectMapper.writeValueAsString(mtbFile)
+            contentType = MediaType.APPLICATION_JSON
+          }
+          .andExpect { status { isAccepted() } }
 
-            val captor = argumentCaptor<DnpmV2MtbFileRequest>()
-            verify(mtbFileSender).send(captor.capture())
-            assertThat(captor.firstValue.content.diagnoses).hasSize(1).allMatch { diagnosis ->
-                diagnosis.code.version == "2014"
-            }
-        }
+      val captor = argumentCaptor<DnpmV2MtbFileRequest>()
+      verify(mtbFileSender).send(captor.capture())
+      assertThat(captor.firstValue.content.diagnoses).hasSize(1).allMatch { diagnosis ->
+        diagnosis.code.version == "2014"
+      }
     }
-
+  }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorArchTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorArchTest.kt
index 308d0cc..1ebf458 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorArchTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/EtlProcessorArchTest.kt
@@ -9,65 +9,79 @@ import org.junit.jupiter.api.Test
 import org.springframework.data.repository.Repository
 
 class EtlProcessorArchTest {
-
     private lateinit var noTestClasses: JavaClasses
 
     @BeforeEach
     fun setUp() {
-        this.noTestClasses = ClassFileImporter()
-            .withImportOption { !(it.contains("/test/") || it.contains("/integrationTest/")) }
-            .importPackages("dev.dnpm.etl.processor")
+        this.noTestClasses =
+            ClassFileImporter()
+                .withImportOption { !(it.contains("/test/") || it.contains("/integrationTest/")) }
+                .importPackages("dev.dnpm.etl.processor")
     }
 
     @Test
     fun noClassesInInputPackageShouldDependOnMonitoringPackage() {
-        val rule = noClasses()
-            .that()
-            .resideInAPackage("..input")
-            .should().dependOnClassesThat()
-            .resideInAnyPackage("..monitoring")
+        val rule =
+            noClasses()
+                .that()
+                .resideInAPackage("..input")
+                .should()
+                .dependOnClassesThat()
+                .resideInAnyPackage("..monitoring")
 
         rule.check(noTestClasses)
     }
 
     @Test
     fun noClassesInInputPackageShouldDependOnRepositories() {
-        val rule = noClasses()
-            .that()
-            .resideInAPackage("..input")
-            .should().dependOnClassesThat().haveSimpleNameEndingWith("Repository")
+        val rule =
+            noClasses()
+                .that()
+                .resideInAPackage("..input")
+                .should()
+                .dependOnClassesThat()
+                .haveSimpleNameEndingWith("Repository")
 
         rule.check(noTestClasses)
     }
 
     @Test
     fun noClassesInOutputPackageShouldDependOnRepositories() {
-        val rule = noClasses()
-            .that()
-            .resideInAPackage("..output")
-            .should().dependOnClassesThat().haveSimpleNameEndingWith("Repository")
+        val rule =
+            noClasses()
+                .that()
+                .resideInAPackage("..output")
+                .should()
+                .dependOnClassesThat()
+                .haveSimpleNameEndingWith("Repository")
 
         rule.check(noTestClasses)
     }
 
     @Test
     fun noClassesInWebPackageShouldDependOnRepositories() {
-        val rule = noClasses()
-            .that()
-            .resideInAPackage("..web")
-            .should().dependOnClassesThat().haveSimpleNameEndingWith("Repository")
+        val rule =
+            noClasses()
+                .that()
+                .resideInAPackage("..web")
+                .should()
+                .dependOnClassesThat()
+                .haveSimpleNameEndingWith("Repository")
 
         rule.check(noTestClasses)
     }
 
     @Test
     fun repositoryClassNamesShouldEndWithRepository() {
-        val rule = classes()
-            .that()
-            .areInterfaces().and().areAssignableTo(Repository::class.java)
-            .should().haveSimpleNameEndingWith("Repository")
+        val rule =
+            classes()
+                .that()
+                .areInterfaces()
+                .and()
+                .areAssignableTo(Repository::class.java)
+                .should()
+                .haveSimpleNameEndingWith("Repository")
 
         rule.check(noTestClasses)
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/AppConfigurationTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/AppConfigurationTest.kt
index 5e25428..f9fe2d4 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/AppConfigurationTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/AppConfigurationTest.kt
@@ -50,127 +50,136 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean
 
 @SpringBootTest
 @ContextConfiguration(
-    classes = [
-        AppConfiguration::class,
-        AppSecurityConfiguration::class,
-        KafkaAutoConfiguration::class,
-        AppKafkaConfiguration::class,
-        AppRestConfiguration::class,
-        ConsentEvaluator::class
-    ]
+    classes =
+        [
+            AppConfiguration::class,
+            AppSecurityConfiguration::class,
+            KafkaAutoConfiguration::class,
+            AppKafkaConfiguration::class,
+            AppRestConfiguration::class,
+            ConsentEvaluator::class,
+        ],
 )
 @MockitoBean(types = [ObjectMapper::class])
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-    ]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+        ],
 )
 class AppConfigurationTest {
-
     @Nested
-    @TestPropertySource(
-        properties = [
-            "app.rest.uri=http://localhost:9000"
-        ]
-    )
-    inner class AppConfigurationRestTest(private val context: ApplicationContext) {
-
+    @TestPropertySource(properties = ["app.rest.uri=http://localhost:9000"])
+    inner class AppConfigurationRestTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseRestMtbFileSenderNotKafkaMtbFileSender() {
             assertThat(context.getBean(RestMtbFileSender::class.java)).isNotNull
-            assertThrows<NoSuchBeanDefinitionException> { context.getBean(KafkaMtbFileSender::class.java) }
+            assertThrows<NoSuchBeanDefinitionException> {
+                context.getBean(KafkaMtbFileSender::class.java)
+            }
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.kafka.servers=localhost:9092",
-            "app.kafka.output-topic=test",
-            "app.kafka.output-response-topic=test-response",
-            "app.kafka.group-id=test"
-        ]
+        properties =
+            [
+                "app.kafka.servers=localhost:9092",
+                "app.kafka.output-topic=test",
+                "app.kafka.output-response-topic=test-response",
+                "app.kafka.group-id=test",
+            ],
     )
     @MockitoBean(types = [RequestRepository::class])
-    inner class AppConfigurationKafkaTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationKafkaTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseKafkaMtbFileSenderNotRestMtbFileSender() {
             assertThrows<NoSuchBeanDefinitionException> { context.getBean(RestMtbFileSender::class.java) }
             assertThat(context.getBean(KafkaMtbFileSender::class.java)).isNotNull
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.rest.uri=http://localhost:9000",
-            "app.kafka.servers=localhost:9092",
-            "app.kafka.output-topic=test",
-            "app.kafka.output-response-topic=test-response",
-            "app.kafka.group-id=test"
-        ]
+        properties =
+            [
+                "app.rest.uri=http://localhost:9000",
+                "app.kafka.servers=localhost:9092",
+                "app.kafka.output-topic=test",
+                "app.kafka.output-response-topic=test-response",
+                "app.kafka.group-id=test",
+            ],
     )
-    inner class AppConfigurationRestInPrecedenceTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationRestInPrecedenceTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseRestMtbFileSenderNotKafkaMtbFileSender() {
             assertThat(context.getBean(RestMtbFileSender::class.java)).isNotNull
-            assertThrows<NoSuchBeanDefinitionException> { context.getBean(KafkaMtbFileSender::class.java) }
+            assertThrows<NoSuchBeanDefinitionException> {
+                context.getBean(KafkaMtbFileSender::class.java)
+            }
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.kafka.servers=localhost:9092",
-            "app.kafka.output-topic=test",
-            "app.kafka.output-response-topic=test-response",
-            "app.kafka.group-id=test"
-        ]
+        properties =
+            [
+                "app.kafka.servers=localhost:9092",
+                "app.kafka.output-topic=test",
+                "app.kafka.output-response-topic=test-response",
+                "app.kafka.group-id=test",
+            ],
     )
-    inner class AppConfigurationWithoutKafkaInputTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationWithoutKafkaInputTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldNotUseKafkaInputListener() {
-            assertThrows<NoSuchBeanDefinitionException> { context.getBean(KafkaInputListener::class.java) }
+            assertThrows<NoSuchBeanDefinitionException> {
+                context.getBean(KafkaInputListener::class.java)
+            }
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.kafka.servers=localhost:9092",
-            "app.kafka.input-topic=test_input",
-            "app.kafka.output-topic=test",
-            "app.kafka.output-response-topic=test-response",
-            "app.kafka.group-id=test"
-        ]
+        properties =
+            [
+                "app.kafka.servers=localhost:9092",
+                "app.kafka.input-topic=test_input",
+                "app.kafka.output-topic=test",
+                "app.kafka.output-response-topic=test-response",
+                "app.kafka.group-id=test",
+            ],
     )
     @MockitoBean(types = [RequestProcessor::class])
-    inner class AppConfigurationUsingKafkaInputTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationUsingKafkaInputTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseKafkaInputListener() {
             assertThat(context.getBean(KafkaInputListener::class.java)).isNotNull
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.transformations[0].path=consent.status",
-            "app.transformations[0].from=rejected",
-            "app.transformations[0].to=accept",
-        ]
+        properties =
+            [
+                "app.transformations[0].path=consent.status",
+                "app.transformations[0].from=rejected",
+                "app.transformations[0].to=accept",
+            ],
     )
-    inner class AppConfigurationTransformationTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationTransformationTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldRecognizeTransformations() {
             val appConfigProperties = context.getBean(AppConfigProperties::class.java)
@@ -178,109 +187,87 @@ class AppConfigurationTest {
             assertThat(appConfigProperties).isNotNull
             assertThat(appConfigProperties.transformations).hasSize(1)
         }
-
     }
 
     @Nested
     inner class AppConfigurationPseudonymizeTest {
-
         @Nested
-        @TestPropertySource(
-            properties = [
-                "app.pseudonymize.generator=buildin"
-            ]
-        )
-        inner class AppConfigurationPseudonymizeGeneratorBuildinTest(private val context: ApplicationContext) {
-
+        @TestPropertySource(properties = ["app.pseudonymize.generator=buildin"])
+        inner class AppConfigurationPseudonymizeGeneratorBuildinTest(
+            private val context: ApplicationContext,
+        ) {
             @Test
             fun shouldUseConfiguredGenerator() {
                 assertThat(context.getBean(AnonymizingGenerator::class.java)).isNotNull
             }
-
         }
 
         @Nested
         @TestPropertySource(
-            properties = [
-                "app.pseudonymize.generator=gpas",
-                "app.pseudonymize.gpas.uri=http://localhost/"
-            ]
+            properties =
+                ["app.pseudonymize.generator=gpas", "app.pseudonymize.gpas.uri=http://localhost/"],
         )
-        inner class AppConfigurationPseudonymizeGeneratorGpasTest(private val context: ApplicationContext) {
-
+        inner class AppConfigurationPseudonymizeGeneratorGpasTest(
+            private val context: ApplicationContext,
+        ) {
             @Test
             fun shouldUseConfiguredGenerator() {
                 assertThat(context.getBean(GpasPseudonymGenerator::class.java)).isNotNull
             }
-
         }
 
         @Nested
         @TestPropertySource(
-            properties = [
-                "app.pseudonymize.generator=gpas",
-                "app.pseudonymize.gpas.soap-endpoint=http://localhost/"
-            ]
+            properties =
+                [
+                    "app.pseudonymize.generator=gpas",
+                    "app.pseudonymize.gpas.soap-endpoint=http://localhost/",
+                ],
         )
-        inner class AppConfigurationPseudonymizeGeneratorGpasSoapTest(private val context: ApplicationContext) {
-
+        inner class AppConfigurationPseudonymizeGeneratorGpasSoapTest(
+            private val context: ApplicationContext,
+        ) {
             @Test
             fun shouldUseConfiguredGenerator() {
                 assertThat(context.getBean(GpasSoapPseudonymGenerator::class.java)).isNotNull
             }
-
         }
 
         @Nested
-        @TestPropertySource(
-            properties = [
-                "app.security.enable-tokens=true"
-            ]
-        )
+        @TestPropertySource(properties = ["app.security.enable-tokens=true"])
         @MockitoBean(
-            types = [
-                InMemoryUserDetailsManager::class,
-                PasswordEncoder::class,
-                TokenRepository::class
-            ]
+            types = [InMemoryUserDetailsManager::class, PasswordEncoder::class, TokenRepository::class],
         )
-        inner class AppConfigurationTokenEnabledTest(private val context: ApplicationContext) {
-
+        inner class AppConfigurationTokenEnabledTest(
+            private val context: ApplicationContext,
+        ) {
             @Test
             fun checkTokenService() {
                 assertThat(context.getBean(TokenService::class.java)).isNotNull
             }
-
         }
 
         @Nested
         @MockitoBean(
-            types = [
-                InMemoryUserDetailsManager::class,
-                PasswordEncoder::class,
-                TokenRepository::class
-            ]
+            types = [InMemoryUserDetailsManager::class, PasswordEncoder::class, TokenRepository::class],
         )
-        inner class AppConfigurationTokenDisabledTest(private val context: ApplicationContext) {
-
+        inner class AppConfigurationTokenDisabledTest(
+            private val context: ApplicationContext,
+        ) {
             @Test
             fun checkTokenService() {
                 assertThrows<NoSuchBeanDefinitionException> { context.getBean(TokenService::class.java) }
             }
-
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.rest.uri=http://localhost:9000",
-            "app.max-retry-attempts=5"
-        ]
+        properties = ["app.rest.uri=http://localhost:9000", "app.max-retry-attempts=5"],
     )
-    inner class AppConfigurationRetryTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationRetryTest(
+        private val context: ApplicationContext,
+    ) {
         private val maxRetryAttempts = 5
 
         @Test
@@ -295,33 +282,32 @@ class AppConfigurationTest {
                 }
             }
         }
-
     }
 
     @Nested
     @TestPropertySource(
-        properties = [
-            "app.consent.service=GICS",
-            "app.consent.gics.uri=http://localhost:9000",
-        ]
+        properties =
+            [
+                "app.consent.service=GICS",
+                "app.consent.gics.uri=http://localhost:9000",
+            ],
     )
-    inner class AppConfigurationConsentGicsTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationConsentGicsTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseConfiguredGenerator() {
             assertThat(context.getBean(GicsConsentService::class.java)).isNotNull
         }
-
     }
 
     @Nested
-    inner class AppConfigurationConsentBuildinTest(private val context: ApplicationContext) {
-
+    inner class AppConfigurationConsentBuildinTest(
+        private val context: ApplicationContext,
+    ) {
         @Test
         fun shouldUseConfiguredGenerator() {
             assertThat(context.getBean(MtbFileConsentService::class.java)).isNotNull
         }
-
     }
-
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/GPasConfigPropertiesTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/GPasConfigPropertiesTest.kt
index 66e0660..bda5b79 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/GPasConfigPropertiesTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/config/GPasConfigPropertiesTest.kt
@@ -7,17 +7,16 @@ import org.springframework.boot.test.context.SpringBootTest
 import org.springframework.boot.test.context.runner.ApplicationContextRunner
 import org.springframework.test.context.ContextConfiguration
 
-
 @SpringBootTest
 @ContextConfiguration(
-    classes = [
-        GPasConfigProperties::class,
-    ]
+    classes =
+        [
+            GPasConfigProperties::class,
+        ],
 )
 class GPasConfigPropertiesTest {
-
     @EnableConfigurationProperties(GPasConfigProperties::class)
-    class TestConfig {}
+    class TestConfig
 
     @Test
     fun shouldUseConfiguredPatientDomainIfPidDomainGiven() {
@@ -25,9 +24,8 @@ class GPasConfigPropertiesTest {
             .withUserConfiguration(TestConfig::class.java)
             .withPropertyValues(
                 "app.pseudonymize.gpas.uri=http://localhost/",
-                "app.pseudonymize.gpas.pid-domain=test-pid-domain"
-            )
-            .run { context ->
+                "app.pseudonymize.gpas.pid-domain=test-pid-domain",
+            ).run { context ->
                 val properties = context.getBean(GPasConfigProperties::class.java)
 
                 assertThat(properties).isNotNull
@@ -41,14 +39,12 @@ class GPasConfigPropertiesTest {
             .withUserConfiguration(TestConfig::class.java)
             .withPropertyValues(
                 "app.pseudonymize.gpas.uri=http://localhost/",
-                "app.pseudonymize.gpas.patient-domain=test-patient-domain"
-            )
-            .run { context ->
+                "app.pseudonymize.gpas.patient-domain=test-patient-domain",
+            ).run { context ->
                 val properties = context.getBean(GPasConfigProperties::class.java)
 
                 assertThat(properties).isNotNull
                 assertThat(properties.patientDomain).isEqualTo("test-patient-domain")
             }
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/helpers.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/helpers.kt
index 6ca420f..5ee6922 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/helpers.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/helpers.kt
@@ -23,8 +23,7 @@ import org.mockito.ArgumentMatchers
 
 @Suppress("UNCHECKED_CAST")
 inline fun <reified T> anyValueClass(): T {
-    val unboxedClass = T::class.java.declaredFields.first().type
-    return ArgumentMatchers.any(unboxedClass as Class<T>)
-        ?: T::class.java.getDeclaredMethod("box-impl", unboxedClass)
-            .invoke(null, null) as T
-}
\ No newline at end of file
+  val unboxedClass = T::class.java.declaredFields.first().type
+  return ArgumentMatchers.any(unboxedClass as Class<T>)
+      ?: T::class.java.getDeclaredMethod("box-impl", unboxedClass).invoke(null, null) as T
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/input/MtbFileRestControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/input/MtbFileRestControllerTest.kt
index 5f2d7ca..e966898 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/input/MtbFileRestControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/input/MtbFileRestControllerTest.kt
@@ -29,6 +29,8 @@ import dev.dnpm.etl.processor.security.TokenRepository
 import dev.dnpm.etl.processor.security.UserRoleRepository
 import dev.dnpm.etl.processor.services.RequestProcessor
 import dev.pcvolkmer.mv64e.mtb.*
+import java.time.Instant
+import java.util.*
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
@@ -48,180 +50,177 @@ import org.springframework.test.context.junit.jupiter.SpringExtension
 import org.springframework.test.web.servlet.MockMvc
 import org.springframework.test.web.servlet.delete
 import org.springframework.test.web.servlet.post
-import java.time.Instant
-import java.util.*
 
 @WebMvcTest(controllers = [MtbFileRestController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        MtbFileRestController::class,
-        AppSecurityConfiguration::class,
-        MtbFileConsentService::class
-    ]
+    classes =
+        [
+            MtbFileRestController::class,
+            AppSecurityConfiguration::class,
+            MtbFileConsentService::class,
+        ]
 )
-@MockitoBean(types = [TokenRepository::class, RequestProcessor::class,  ConsentEvaluator::class])
+@MockitoBean(types = [TokenRepository::class, RequestProcessor::class, ConsentEvaluator::class])
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-        "app.security.admin-user=admin",
-        "app.security.admin-password={noop}very-secret",
-        "app.security.enable-tokens=true"
-    ]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+            "app.security.admin-user=admin",
+            "app.security.admin-password={noop}very-secret",
+            "app.security.enable-tokens=true",
+        ]
 )
 class MtbFileRestControllerTest {
 
-    lateinit var mockMvc: MockMvc
-    lateinit var requestProcessor: RequestProcessor
-    lateinit var consentEvaluator: ConsentEvaluator
-
-    @BeforeEach
-    fun setup(
-        @Autowired mockMvc: MockMvc,
-        @Autowired requestProcessor: RequestProcessor,
-        @Autowired consentEvaluator: ConsentEvaluator
-    ) {
-        this.mockMvc = mockMvc
-        this.requestProcessor = requestProcessor
-        this.consentEvaluator = consentEvaluator
-
-        doAnswer {
-            ConsentEvaluation(TtpConsentStatus.BROAD_CONSENT_GIVEN, true)
-        }.whenever(consentEvaluator).check(any())
-    }
-
-    @Test
-    fun testShouldGrantPermissionToSendMtbFile() {
-        mockMvc.post("/mtbfile") {
-            with(user("onkostarserver").roles("MTBFILE"))
-            contentType = MediaType.APPLICATION_JSON
-            content = ObjectMapper().writeValueAsString(mtbFile)
-        }.andExpect {
-            status { isAccepted() }
+  lateinit var mockMvc: MockMvc
+  lateinit var requestProcessor: RequestProcessor
+  lateinit var consentEvaluator: ConsentEvaluator
+
+  @BeforeEach
+  fun setup(
+      @Autowired mockMvc: MockMvc,
+      @Autowired requestProcessor: RequestProcessor,
+      @Autowired consentEvaluator: ConsentEvaluator,
+  ) {
+    this.mockMvc = mockMvc
+    this.requestProcessor = requestProcessor
+    this.consentEvaluator = consentEvaluator
+
+    doAnswer { ConsentEvaluation(TtpConsentStatus.BROAD_CONSENT_GIVEN, true) }
+        .whenever(consentEvaluator)
+        .check(any())
+  }
+
+  @Test
+  fun testShouldGrantPermissionToSendMtbFile() {
+    mockMvc
+        .post("/mtbfile") {
+          with(user("onkostarserver").roles("MTBFILE"))
+          contentType = MediaType.APPLICATION_JSON
+          content = ObjectMapper().writeValueAsString(mtbFile)
         }
-
-        verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
-    }
-
+        .andExpect { status { isAccepted() } }
+
+    verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
+  }
+
+  @Test
+  fun testShouldGrantPermissionToSendMtbFileToAdminUser() {
+    mockMvc
+        .post("/mtbfile") {
+          with(user("onkostarserver").roles("ADMIN"))
+          contentType = MediaType.APPLICATION_JSON
+          content = ObjectMapper().writeValueAsString(mtbFile)
+        }
+        .andExpect { status { isAccepted() } }
+
+    verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
+  }
+
+  @Test
+  fun testShouldDenyPermissionToSendMtbFile() {
+    mockMvc
+        .post("/mtbfile") {
+          with(anonymous())
+          contentType = MediaType.APPLICATION_JSON
+          content = ObjectMapper().writeValueAsString(mtbFile)
+        }
+        .andExpect { status { isUnauthorized() } }
+
+    verify(requestProcessor, never()).processMtbFile(any<Mtb>())
+  }
+
+  @Test
+  fun testShouldDenyPermissionToSendMtbFileForUser() {
+    mockMvc
+        .post("/mtbfile") {
+          with(user("fakeuser").roles("USER"))
+          contentType = MediaType.APPLICATION_JSON
+          content = ObjectMapper().writeValueAsString(mtbFile)
+        }
+        .andExpect { status { isForbidden() } }
+
+    verify(requestProcessor, never()).processMtbFile(any<Mtb>())
+  }
+
+  @Test
+  fun testShouldGrantPermissionToDeletePatientData() {
+    mockMvc
+        .delete("/mtbfile/12345678") { with(user("onkostarserver").roles("MTBFILE")) }
+        .andExpect { status { isAccepted() } }
+
+    verify(requestProcessor, times(1))
+        .processDeletion(anyValueClass(), eq(TtpConsentStatus.UNKNOWN_CHECK_FILE))
+  }
+
+  @Test
+  fun testShouldDenyPermissionToDeletePatientData() {
+    mockMvc
+        .delete("/mtbfile/12345678") { with(anonymous()) }
+        .andExpect { status { isUnauthorized() } }
+
+    verify(requestProcessor, never()).processDeletion(anyValueClass(), any())
+  }
+
+  @Nested
+  @MockitoBean(types = [UserRoleRepository::class, ClientRegistrationRepository::class])
+  @TestPropertySource(
+      properties =
+          [
+              "app.pseudonymize.generator=BUILDIN",
+              "app.security.admin-user=admin",
+              "app.security.admin-password={noop}very-secret",
+              "app.security.enable-tokens=true",
+              "app.security.enable-oidc=true",
+          ]
+  )
+  inner class WithOidcEnabled {
     @Test
     fun testShouldGrantPermissionToSendMtbFileToAdminUser() {
-        mockMvc.post("/mtbfile") {
+      mockMvc
+          .post("/mtbfile") {
             with(user("onkostarserver").roles("ADMIN"))
             contentType = MediaType.APPLICATION_JSON
             content = ObjectMapper().writeValueAsString(mtbFile)
-        }.andExpect {
-            status { isAccepted() }
-        }
-
-        verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
-    }
-
-    @Test
-    fun testShouldDenyPermissionToSendMtbFile() {
-        mockMvc.post("/mtbfile") {
-            with(anonymous())
-            contentType = MediaType.APPLICATION_JSON
-            content = ObjectMapper().writeValueAsString(mtbFile)
-        }.andExpect {
-            status { isUnauthorized() }
-        }
+          }
+          .andExpect { status { isAccepted() } }
 
-        verify(requestProcessor, never()).processMtbFile(any<Mtb>())
+      verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
     }
 
     @Test
-    fun testShouldDenyPermissionToSendMtbFileForUser() {
-        mockMvc.post("/mtbfile") {
-            with(user("fakeuser").roles("USER"))
+    fun testShouldGrantPermissionToSendMtbFileToUser() {
+      mockMvc
+          .post("/mtbfile") {
+            with(user("onkostarserver").roles("USER"))
             contentType = MediaType.APPLICATION_JSON
             content = ObjectMapper().writeValueAsString(mtbFile)
-        }.andExpect {
-            status { isForbidden() }
-        }
-
-        verify(requestProcessor, never()).processMtbFile(any<Mtb>())
-    }
-
-    @Test
-    fun testShouldGrantPermissionToDeletePatientData() {
-        mockMvc.delete("/mtbfile/12345678") {
-            with(user("onkostarserver").roles("MTBFILE"))
-        }.andExpect {
-            status { isAccepted() }
-        }
+          }
+          .andExpect { status { isAccepted() } }
 
-        verify(requestProcessor, times(1)).processDeletion(anyValueClass(),  eq(TtpConsentStatus.UNKNOWN_CHECK_FILE))
+      verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
     }
+  }
 
-    @Test
-    fun testShouldDenyPermissionToDeletePatientData() {
-        mockMvc.delete("/mtbfile/12345678") {
-            with(anonymous())
-        }.andExpect {
-            status { isUnauthorized() }
-        }
+  companion object {
 
-        verify(requestProcessor, never()).processDeletion(anyValueClass(), any())
-    }
-
-    @Nested
-    @MockitoBean(types = [UserRoleRepository::class, ClientRegistrationRepository::class])
-    @TestPropertySource(
-        properties = [
-            "app.pseudonymize.generator=BUILDIN",
-            "app.security.admin-user=admin",
-            "app.security.admin-password={noop}very-secret",
-            "app.security.enable-tokens=true",
-            "app.security.enable-oidc=true"
-        ]
-    )
-    inner class WithOidcEnabled {
-        @Test
-        fun testShouldGrantPermissionToSendMtbFileToAdminUser() {
-            mockMvc.post("/mtbfile") {
-                with(user("onkostarserver").roles("ADMIN"))
-                contentType = MediaType.APPLICATION_JSON
-                content = ObjectMapper().writeValueAsString(mtbFile)
-            }.andExpect {
-                status { isAccepted() }
-            }
-
-            verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
-        }
-
-        @Test
-        fun testShouldGrantPermissionToSendMtbFileToUser() {
-            mockMvc.post("/mtbfile") {
-                with(user("onkostarserver").roles("USER"))
-                contentType = MediaType.APPLICATION_JSON
-                content = ObjectMapper().writeValueAsString(mtbFile)
-            }.andExpect {
-                status { isAccepted() }
-            }
-
-            verify(requestProcessor, times(1)).processMtbFile(any<Mtb>())
-        }
-    }
-
-    companion object {
-
-        val mtbFile = Mtb.builder()
-            .patient(
-                Patient.builder()
-                    .id("PID")
-                    .build()
-            )
+    val mtbFile =
+        Mtb.builder()
+            .patient(Patient.builder().id("PID").build())
             .episodesOfCare(
                 listOf(
                     MtbEpisodeOfCare.builder()
                         .id("1")
                         .patient(Reference.builder().id("PID").build())
-                        .period(PeriodDate.builder().start(Date.from(Instant.parse("2023-08-08T02:00:00.00Z"))).build())
+                        .period(
+                            PeriodDate.builder()
+                                .start(Date.from(Instant.parse("2023-08-08T02:00:00.00Z")))
+                                .build()
+                        )
                         .build()
                 )
             )
             .build()
-
-    }
-
+  }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/monitoring/RequestRepositoryTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/monitoring/RequestRepositoryTest.kt
index 428bca9..428a99d 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/monitoring/RequestRepositoryTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/monitoring/RequestRepositoryTest.kt
@@ -21,6 +21,7 @@ package dev.dnpm.etl.processor.monitoring
 
 import dev.dnpm.etl.processor.*
 import dev.dnpm.etl.processor.output.MtbFileSender
+import java.time.Instant
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
@@ -32,7 +33,6 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean
 import org.springframework.test.context.junit.jupiter.SpringExtension
 import org.springframework.transaction.annotation.Transactional
 import org.testcontainers.junit.jupiter.Testcontainers
-import java.time.Instant
 
 @Testcontainers
 @ExtendWith(SpringExtension::class)
@@ -41,35 +41,30 @@ import java.time.Instant
 @Transactional
 @MockitoBean(types = [MtbFileSender::class])
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=buildin",
-        "app.rest.uri=http://example.com"
-    ]
+    properties = ["app.pseudonymize.generator=buildin", "app.rest.uri=http://example.com"]
 )
 class RequestRepositoryTest : AbstractTestcontainerTest() {
 
-    private lateinit var requestRepository: RequestRepository
+  private lateinit var requestRepository: RequestRepository
 
-    @BeforeEach
-    fun setUp(
-        @Autowired requestRepository: RequestRepository
-    ) {
-        this.requestRepository = requestRepository
-    }
+  @BeforeEach
+  fun setUp(@Autowired requestRepository: RequestRepository) {
+    this.requestRepository = requestRepository
+  }
 
-    @Test
-    fun shouldSaveRequest() {
-        val request = Request(
+  @Test
+  fun shouldSaveRequest() {
+    val request =
+        Request(
             randomRequestId(),
             PatientPseudonym("TEST_12345678901"),
             PatientId("P1"),
             Fingerprint("0123456789abcdef1"),
             RequestType.MTB_FILE,
             RequestStatus.WARNING,
-            Instant.parse("2023-07-07T00:00:00Z")
+            Instant.parse("2023-07-07T00:00:00Z"),
         )
 
-        requestRepository.save(request)
-    }
-
-}
\ No newline at end of file
+    requestRepository.save(request)
+  }
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/pseudonym/GpasPseudonymGeneratorTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/pseudonym/GpasPseudonymGeneratorTest.kt
index 578810e..cccd614 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/pseudonym/GpasPseudonymGeneratorTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/pseudonym/GpasPseudonymGeneratorTest.kt
@@ -41,7 +41,6 @@ import java.io.IOException
 import java.net.URI
 
 class GpasPseudonymGeneratorTest {
-
     private lateinit var mockRestServiceServer: MockRestServiceServer
     private lateinit var generator: GpasPseudonymGenerator
     private lateinit var restTemplate: RestTemplate
@@ -50,14 +49,8 @@ class GpasPseudonymGeneratorTest {
     @BeforeEach
     fun setup() {
         val retryTemplate = RetryTemplateBuilder().customPolicy(SimpleRetryPolicy(1)).build()
-        val gPasConfigProperties = GPasConfigProperties(
-            CONFIGURED_URI,
-            null,
-            null,
-            "test", "test2",
-            null,
-            null
-        )
+        val gPasConfigProperties =
+            GPasConfigProperties(CONFIGURED_URI, null, null, "test", "test2", null, null)
 
         this.restTemplate = RestTemplate()
         this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
@@ -71,13 +64,8 @@ class GpasPseudonymGeneratorTest {
             .expect(method(HttpMethod.POST))
             .andExpect(requestTo(EXPECTED_URI))
             .andRespond {
-                withStatus(HttpStatus.OK).body(
-                    getDummyResponseBody(
-                        "1234",
-                        "test",
-                        "test1234ABCDEF567890"
-                    )
-                )
+                withStatus(HttpStatus.OK)
+                    .body(getDummyResponseBody("1234", "test", "test1234ABCDEF567890"))
                     .createResponse(it)
             }
 
@@ -89,9 +77,7 @@ class GpasPseudonymGeneratorTest {
         this.mockRestServiceServer
             .expect(method(HttpMethod.POST))
             .andExpect(requestTo(EXPECTED_URI))
-            .andRespond {
-                withException(IOException("Simulated IO error")).createResponse(it)
-            }
+            .andRespond { withException(IOException("Simulated IO error")).createResponse(it) }
 
         assertThrows<PseudonymRequestFailed> { this.generator.generate("ID1234") }
     }
@@ -105,52 +91,56 @@ class GpasPseudonymGeneratorTest {
                 withStatus(HttpStatus.FOUND)
                     .header(
                         HttpHeaders.LOCATION,
-                        $$"https://localhost/ttp-fhir/fhir/gpas/$pseudonymizeAllowCreate"
-                    )
-                    .createResponse(it)
+                        $$"https://localhost/ttp-fhir/fhir/gpas/$pseudonymizeAllowCreate",
+                    ).createResponse(it)
             }
 
         assertThrows<PseudonymRequestFailed> { this.generator.generate("ID1234") }
     }
 
     companion object {
-
         const val CONFIGURED_URI = "https://localhost/ttp-fhir/fhir/gpas"
 
-        val EXPECTED_URI = URIBuilder(URI.create(CONFIGURED_URI)).appendPath($$"$pseudonymizeAllowCreate")
-            .build()!!
+        val EXPECTED_URI =
+            URIBuilder(URI.create(CONFIGURED_URI)).appendPath($$"$pseudonymizeAllowCreate").build()!!
 
-        fun getDummyResponseBody(original: String, target: String, pseudonym: String) = """{
-          "resourceType": "Parameters",
-          "parameter": [
+        fun getDummyResponseBody(
+            original: String,
+            target: String,
+            pseudonym: String,
+        ) = """
             {
-              "name": "pseudonym",
-              "part": [
-                {
-                  "name": "original",
-                  "valueIdentifier": {
-                    "system": "https://ths-greifswald.de/gpas",
-                    "value": "$original"
-                  }
-                },
-                {
-                  "name": "target",
-                  "valueIdentifier": {
-                    "system": "https://ths-greifswald.de/gpas",
-                    "value": "$target"
-                  }
-                },
+              "resourceType": "Parameters",
+              "parameter": [
                 {
                   "name": "pseudonym",
-                  "valueIdentifier": {
-                    "system": "https://ths-greifswald.de/gpas",
-                    "value": "$pseudonym"
-                  }
+                  "part": [
+                    {
+                      "name": "original",
+                      "valueIdentifier": {
+                        "system": "https://ths-greifswald.de/gpas",
+                        "value": "$original"
+                      }
+                    },
+                    {
+                      "name": "target",
+                      "valueIdentifier": {
+                        "system": "https://ths-greifswald.de/gpas",
+                        "value": "$target"
+                      }
+                    },
+                    {
+                      "name": "pseudonym",
+                      "valueIdentifier": {
+                        "system": "https://ths-greifswald.de/gpas",
+                        "value": "$pseudonym"
+                      }
+                    }
+                  ]
                 }
               ]
             }
-          ]
-        }""".trimIndent()
-
+            
+            """.trimIndent()
     }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/services/RequestServiceIntegrationTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/services/RequestServiceIntegrationTest.kt
index 9fcdc16..d9489f2 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/services/RequestServiceIntegrationTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/services/RequestServiceIntegrationTest.kt
@@ -25,6 +25,7 @@ import dev.dnpm.etl.processor.monitoring.RequestRepository
 import dev.dnpm.etl.processor.monitoring.RequestStatus
 import dev.dnpm.etl.processor.monitoring.RequestType
 import dev.dnpm.etl.processor.output.MtbFileSender
+import java.time.Instant
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
@@ -36,7 +37,6 @@ import org.springframework.test.context.bean.override.mockito.MockitoBean
 import org.springframework.test.context.junit.jupiter.SpringExtension
 import org.springframework.transaction.annotation.Transactional
 import org.testcontainers.junit.jupiter.Testcontainers
-import java.time.Instant
 
 @Testcontainers
 @ExtendWith(SpringExtension::class)
@@ -44,101 +44,95 @@ import java.time.Instant
 @Transactional
 @MockitoBean(types = [MtbFileSender::class])
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=buildin",
-        "app.rest.uri=http://example.com"
-    ]
+    properties = ["app.pseudonymize.generator=buildin", "app.rest.uri=http://example.com"]
 )
 class RequestServiceIntegrationTest : AbstractTestcontainerTest() {
 
-    private lateinit var requestRepository: RequestRepository
-
-    private lateinit var requestService: RequestService
-
-    @BeforeEach
-    fun setup(
-        @Autowired requestRepository: RequestRepository
-    ) {
-        this.requestRepository = requestRepository
-        this.requestService = RequestService(requestRepository)
-    }
-
-    @Test
-    fun shouldResultInEmptyRequestList() {
-        val actual = requestService.allRequestsByPatientPseudonym(TEST_PATIENT_PSEUDONYM)
-
-        assertThat(actual).isEmpty()
-    }
-
-    private fun setupTestData() {
-        // Prepare DB
-        this.requestRepository.saveAll(
-            listOf(
-                Request(
-                    randomRequestId(),
-                    PatientPseudonym("TEST_12345678901"),
-                    PatientId("P1"),
-                    Fingerprint("0123456789abcdef1"),
-                    RequestType.MTB_FILE,
-                    RequestStatus.SUCCESS,
-                    Instant.parse("2023-07-07T02:00:00Z")
-                ),
-                // Should be ignored - wrong patient ID -->
-                Request(
-                    randomRequestId(),
-                    PatientPseudonym("TEST_12345678902"),
-                    PatientId("P2"),
-                    Fingerprint("0123456789abcdef2"),
-                    RequestType.MTB_FILE,
-                    RequestStatus.WARNING,
-                    Instant.parse("2023-08-08T00:00:00Z")
-                ),
-                // <--
-                Request(
-                    randomRequestId(),
-                    PatientPseudonym("TEST_12345678901"),
-                    PatientId("P2"),
-                    Fingerprint("0123456789abcdee1"),
-                    RequestType.DELETE,
-                    RequestStatus.SUCCESS,
-                    Instant.parse("2023-08-08T02:00:00Z")
-                )
-            )
+  private lateinit var requestRepository: RequestRepository
+
+  private lateinit var requestService: RequestService
+
+  @BeforeEach
+  fun setup(@Autowired requestRepository: RequestRepository) {
+    this.requestRepository = requestRepository
+    this.requestService = RequestService(requestRepository)
+  }
+
+  @Test
+  fun shouldResultInEmptyRequestList() {
+    val actual = requestService.allRequestsByPatientPseudonym(TEST_PATIENT_PSEUDONYM)
+
+    assertThat(actual).isEmpty()
+  }
+
+  private fun setupTestData() {
+    // Prepare DB
+    this.requestRepository.saveAll(
+        listOf(
+            Request(
+                randomRequestId(),
+                PatientPseudonym("TEST_12345678901"),
+                PatientId("P1"),
+                Fingerprint("0123456789abcdef1"),
+                RequestType.MTB_FILE,
+                RequestStatus.SUCCESS,
+                Instant.parse("2023-07-07T02:00:00Z"),
+            ),
+            // Should be ignored - wrong patient ID -->
+            Request(
+                randomRequestId(),
+                PatientPseudonym("TEST_12345678902"),
+                PatientId("P2"),
+                Fingerprint("0123456789abcdef2"),
+                RequestType.MTB_FILE,
+                RequestStatus.WARNING,
+                Instant.parse("2023-08-08T00:00:00Z"),
+            ),
+            // <--
+            Request(
+                randomRequestId(),
+                PatientPseudonym("TEST_12345678901"),
+                PatientId("P2"),
+                Fingerprint("0123456789abcdee1"),
+                RequestType.DELETE,
+                RequestStatus.SUCCESS,
+                Instant.parse("2023-08-08T02:00:00Z"),
+            ),
         )
-    }
-
-    @Test
-    fun shouldResultInSortedRequestList() {
-        setupTestData()
+    )
+  }
 
-        val actual = requestService.allRequestsByPatientPseudonym(TEST_PATIENT_PSEUDONYM)
+  @Test
+  fun shouldResultInSortedRequestList() {
+    setupTestData()
 
-        assertThat(actual).hasSize(2)
-        assertThat(actual[0].fingerprint).isEqualTo(Fingerprint("0123456789abcdee1"))
-        assertThat(actual[1].fingerprint).isEqualTo(Fingerprint("0123456789abcdef1"))
-    }
+    val actual = requestService.allRequestsByPatientPseudonym(TEST_PATIENT_PSEUDONYM)
 
-    @Test
-    fun shouldReturnDeleteRequestAsLastRequest() {
-        setupTestData()
+    assertThat(actual).hasSize(2)
+    assertThat(actual[0].fingerprint).isEqualTo(Fingerprint("0123456789abcdee1"))
+    assertThat(actual[1].fingerprint).isEqualTo(Fingerprint("0123456789abcdef1"))
+  }
 
-        val actual = requestService.isLastRequestWithKnownStatusDeletion(TEST_PATIENT_PSEUDONYM)
+  @Test
+  fun shouldReturnDeleteRequestAsLastRequest() {
+    setupTestData()
 
-        assertThat(actual).isTrue()
-    }
+    val actual = requestService.isLastRequestWithKnownStatusDeletion(TEST_PATIENT_PSEUDONYM)
 
-    @Test
-    fun shouldReturnLastMtbFileRequest() {
-        setupTestData()
+    assertThat(actual).isTrue()
+  }
 
-        val actual = requestService.lastMtbFileRequestForPatientPseudonym(TEST_PATIENT_PSEUDONYM)
+  @Test
+  fun shouldReturnLastMtbFileRequest() {
+    setupTestData()
 
-        assertThat(actual).isNotNull
-        assertThat(actual?.fingerprint).isEqualTo(Fingerprint("0123456789abcdef1"))
-    }
+    val actual = requestService.lastMtbFileRequestForPatientPseudonym(TEST_PATIENT_PSEUDONYM)
 
-    companion object {
-        val TEST_PATIENT_PSEUDONYM = PatientPseudonym("TEST_12345678901")
-    }
+    assertThat(actual).isNotNull
+    assertThat(actual?.fingerprint).isEqualTo(Fingerprint("0123456789abcdef1"))
+  }
 
-}
\ No newline at end of file
+  companion object {
+    val TEST_PATIENT_PSEUDONYM = PatientPseudonym("TEST_12345678901")
+  }
+}
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/ConfigControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/ConfigControllerTest.kt
index 8e5d38e..c081319 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/ConfigControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/ConfigControllerTest.kt
@@ -32,6 +32,7 @@ import dev.dnpm.etl.processor.security.TokenService
 import dev.dnpm.etl.processor.security.UserRoleService
 import dev.dnpm.etl.processor.services.RequestProcessor
 import dev.dnpm.etl.processor.services.TransformationService
+import java.time.Instant
 import org.assertj.core.api.Assertions.assertThat
 import org.htmlunit.WebClient
 import org.htmlunit.html.HtmlPage
@@ -64,320 +65,288 @@ import org.springframework.test.web.servlet.htmlunit.MockMvcWebClientBuilder
 import org.springframework.web.context.WebApplicationContext
 import reactor.core.publisher.Sinks
 import reactor.test.StepVerifier
-import java.time.Instant
 
 abstract class MockSink : Sinks.Many<Boolean>
 
 @WebMvcTest(controllers = [ConfigController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        ConfigController::class,
-        AppConfiguration::class,
-        AppSecurityConfiguration::class
-    ]
-)
-@TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN"
-    ]
+    classes = [ConfigController::class, AppConfiguration::class, AppSecurityConfiguration::class]
 )
+@TestPropertySource(properties = ["app.pseudonymize.generator=BUILDIN"])
 @MockitoBean(name = "configsUpdateProducer", types = [MockSink::class])
 @MockitoBean(
-    types = [
-        Generator::class,
-        MtbFileSender::class,
-        RequestProcessor::class,
-        TransformationService::class,
-        GPasConnectionCheckService::class,
-        RestConnectionCheckService::class,
-        GIcsConnectionCheckService::class
-    ]
+    types =
+        [
+            Generator::class,
+            MtbFileSender::class,
+            RequestProcessor::class,
+            TransformationService::class,
+            GPasConnectionCheckService::class,
+            RestConnectionCheckService::class,
+            GIcsConnectionCheckService::class,
+        ]
 )
 class ConfigControllerTest {
 
-    private lateinit var mockMvc: MockMvc
-    private lateinit var webClient: WebClient
+  private lateinit var mockMvc: MockMvc
+  private lateinit var webClient: WebClient
+
+  private lateinit var requestProcessor: RequestProcessor
+  private lateinit var connectionCheckUpdateProducer: Sinks.Many<ConnectionCheckResult>
+
+  @BeforeEach
+  fun setup(
+      @Autowired mockMvc: MockMvc,
+      @Autowired requestProcessor: RequestProcessor,
+      @Autowired connectionCheckUpdateProducer: Sinks.Many<ConnectionCheckResult>,
+  ) {
+    this.mockMvc = mockMvc
+    this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
+    this.requestProcessor = requestProcessor
+    this.connectionCheckUpdateProducer = connectionCheckUpdateProducer
+
+    webClient.options.isThrowExceptionOnScriptError = false
+  }
+
+  @Test
+  fun testShouldRequestConfigPageIfLoggedIn() {
+    mockMvc
+        .get("/configs") {
+          with(user("admin").roles("ADMIN"))
+          accept(MediaType.TEXT_HTML)
+        }
+        .andExpect {
+          status { isOk() }
+          view { name("configs") }
+        }
+  }
+
+  @Test
+  fun testShouldRedirectToLoginPageIfNotLoggedIn() {
+    mockMvc
+        .get("/configs") {
+          with(anonymous())
+          accept(MediaType.TEXT_HTML)
+        }
+        .andExpect {
+          status { isFound() }
+          header { stringValues(HttpHeaders.LOCATION, "http://localhost/login") }
+        }
+  }
 
-    private lateinit var requestProcessor: RequestProcessor
-    private lateinit var connectionCheckUpdateProducer: Sinks.Many<ConnectionCheckResult>
+  @Nested
+  @TestPropertySource(
+      properties = ["app.security.enable-tokens=true", "app.security.admin-user=admin"]
+  )
+  @MockitoBean(types = [TokenService::class])
+  inner class WithTokensEnabled {
+    private lateinit var tokenService: TokenService
 
     @BeforeEach
-    fun setup(
-        @Autowired mockMvc: MockMvc,
-        @Autowired requestProcessor: RequestProcessor,
-        @Autowired connectionCheckUpdateProducer: Sinks.Many<ConnectionCheckResult>
-    ) {
-        this.mockMvc = mockMvc
-        this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
-        this.requestProcessor = requestProcessor
-        this.connectionCheckUpdateProducer = connectionCheckUpdateProducer
-
-        webClient.options.isThrowExceptionOnScriptError = false
+    fun setup(@Autowired tokenService: TokenService) {
+      webClient.options.isThrowExceptionOnScriptError = false
+
+      this.tokenService = tokenService
     }
 
     @Test
-    fun testShouldRequestConfigPageIfLoggedIn() {
-        mockMvc.get("/configs") {
+    fun testShouldSaveNewToken() {
+      mockMvc
+          .post("/configs/tokens") {
             with(user("admin").roles("ADMIN"))
             accept(MediaType.TEXT_HTML)
-        }.andExpect {
-            status { isOk() }
-            view { name("configs") }
-        }
+            contentType = MediaType.APPLICATION_FORM_URLENCODED
+            content = "name=Testtoken"
+          }
+          .andExpect {
+            status { is2xxSuccessful() }
+            view { name("configs/tokens") }
+          }
+
+      val captor = argumentCaptor<String>()
+      verify(tokenService, times(1)).addToken(captor.capture())
+
+      assertThat(captor.firstValue).isEqualTo("Testtoken")
     }
 
     @Test
-    fun testShouldRedirectToLoginPageIfNotLoggedIn() {
-        mockMvc.get("/configs") {
-            with(anonymous())
+    fun testShouldNotSaveTokenWithExstingName() {
+      whenever(tokenService.addToken(anyString()))
+          .thenReturn(Result.failure(RuntimeException("Testfailure")))
+
+      mockMvc
+          .post("/configs/tokens") {
+            with(user("admin").roles("ADMIN"))
             accept(MediaType.TEXT_HTML)
-        }.andExpect {
-            status { isFound() }
-            header {
-                stringValues(HttpHeaders.LOCATION, "http://localhost/login")
-            }
-        }
+            contentType = MediaType.APPLICATION_FORM_URLENCODED
+            content = "name=Testtoken"
+          }
+          .andExpect {
+            status { is2xxSuccessful() }
+            view { name("configs/tokens") }
+          }
+
+      val captor = argumentCaptor<String>()
+      verify(tokenService, times(1)).addToken(captor.capture())
+
+      assertThat(captor.firstValue).isEqualTo("Testtoken")
     }
 
-    @Nested
-    @TestPropertySource(
-        properties = [
-            "app.security.enable-tokens=true",
-            "app.security.admin-user=admin"
-        ]
-    )
-    @MockitoBean(
-        types = [
-            TokenService::class
-        ]
-    )
-    inner class WithTokensEnabled {
-        private lateinit var tokenService: TokenService
-
-        @BeforeEach
-        fun setup(
-            @Autowired tokenService: TokenService
-        ) {
-            webClient.options.isThrowExceptionOnScriptError = false
-
-            this.tokenService = tokenService
-        }
-
-        @Test
-        fun testShouldSaveNewToken() {
-            mockMvc.post("/configs/tokens") {
-                with(user("admin").roles("ADMIN"))
-                accept(MediaType.TEXT_HTML)
-                contentType = MediaType.APPLICATION_FORM_URLENCODED
-                content = "name=Testtoken"
-            }.andExpect {
-                status { is2xxSuccessful() }
-                view { name("configs/tokens") }
-            }
-
-            val captor = argumentCaptor<String>()
-            verify(tokenService, times(1)).addToken(captor.capture())
-
-            assertThat(captor.firstValue).isEqualTo("Testtoken")
-        }
-
-        @Test
-        fun testShouldNotSaveTokenWithExstingName() {
-            whenever(tokenService.addToken(anyString())).thenReturn(
-                Result.failure(
-                    RuntimeException(
-                        "Testfailure"
-                    )
-                )
-            )
-
-            mockMvc.post("/configs/tokens") {
-                with(user("admin").roles("ADMIN"))
-                accept(MediaType.TEXT_HTML)
-                contentType = MediaType.APPLICATION_FORM_URLENCODED
-                content = "name=Testtoken"
-            }.andExpect {
-                status { is2xxSuccessful() }
-                view { name("configs/tokens") }
-            }
-
-            val captor = argumentCaptor<String>()
-            verify(tokenService, times(1)).addToken(captor.capture())
-
-            assertThat(captor.firstValue).isEqualTo("Testtoken")
-        }
-
-        @Test
-        fun testShouldDeleteToken() {
-            mockMvc.delete("/configs/tokens/42") {
-                with(user("admin").roles("ADMIN"))
-                accept(MediaType.TEXT_HTML)
-            }.andExpect {
-                status { is2xxSuccessful() }
-                view { name("configs/tokens") }
-            }
-
-            val captor = argumentCaptor<Long>()
-            verify(tokenService, times(1)).deleteToken(captor.capture())
+    @Test
+    fun testShouldDeleteToken() {
+      mockMvc
+          .delete("/configs/tokens/42") {
+            with(user("admin").roles("ADMIN"))
+            accept(MediaType.TEXT_HTML)
+          }
+          .andExpect {
+            status { is2xxSuccessful() }
+            view { name("configs/tokens") }
+          }
 
-            assertThat(captor.firstValue).isEqualTo(42)
-        }
+      val captor = argumentCaptor<Long>()
+      verify(tokenService, times(1)).deleteToken(captor.capture())
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldRenderConfigPageWithTokens() {
-            val page = webClient.getPage<HtmlPage>("http://localhost/configs")
-            assertThat(
-                page.getElementById("tokens")
-            ).isNotNull
-        }
+      assertThat(captor.firstValue).isEqualTo(42)
     }
 
-    @Nested
-    @TestPropertySource(
-        properties = [
-            "app.security.enable-tokens=false"
-        ]
-    )
-    inner class WithTokensDisabled {
-        @BeforeEach
-        fun setup() {
-            webClient.options.isThrowExceptionOnScriptError = false
-        }
-
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldRenderConfigPageWithoutTokens() {
-            val page = webClient.getPage<HtmlPage>("http://localhost/configs")
-            assertThat(
-                page.getElementById("tokens")
-            ).isNull()
-        }
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldRenderConfigPageWithTokens() {
+      val page = webClient.getPage<HtmlPage>("http://localhost/configs")
+      assertThat(page.getElementById("tokens")).isNotNull
     }
+  }
 
-    @Nested
-    @TestPropertySource(
-        properties = [
-            "app.security.enable-tokens=false",
-            "app.security.admin-user=admin",
-            "app.security.admin-password={noop}very-secret"
-        ]
-    )
-    @MockitoBean(
-        types = [
-            UserRoleService::class
-        ]
-    )
-    inner class WithUserRolesEnabled {
-        private lateinit var userRoleService: UserRoleService
+  @Nested
+  @TestPropertySource(properties = ["app.security.enable-tokens=false"])
+  inner class WithTokensDisabled {
+    @BeforeEach
+    fun setup() {
+      webClient.options.isThrowExceptionOnScriptError = false
+    }
 
-        @BeforeEach
-        fun setup(
-            @Autowired userRoleService: UserRoleService
-        ) {
-            webClient.options.isThrowExceptionOnScriptError = false
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldRenderConfigPageWithoutTokens() {
+      val page = webClient.getPage<HtmlPage>("http://localhost/configs")
+      assertThat(page.getElementById("tokens")).isNull()
+    }
+  }
+
+  @Nested
+  @TestPropertySource(
+      properties =
+          [
+              "app.security.enable-tokens=false",
+              "app.security.admin-user=admin",
+              "app.security.admin-password={noop}very-secret",
+          ]
+  )
+  @MockitoBean(types = [UserRoleService::class])
+  inner class WithUserRolesEnabled {
+    private lateinit var userRoleService: UserRoleService
 
-            this.userRoleService = userRoleService
-        }
+    @BeforeEach
+    fun setup(@Autowired userRoleService: UserRoleService) {
+      webClient.options.isThrowExceptionOnScriptError = false
 
-        @Test
-        fun testShouldDeleteUserRole() {
-            mockMvc.delete("/configs/userroles/42") {
-                with(user("admin").roles("ADMIN"))
-                accept(MediaType.TEXT_HTML)
-            }.andExpect {
-                status { is2xxSuccessful() }
-                view { name("configs/userroles") }
-            }
+      this.userRoleService = userRoleService
+    }
 
-            val captor = argumentCaptor<Long>()
-            verify(userRoleService, times(1)).deleteUserRole(captor.capture())
+    @Test
+    fun testShouldDeleteUserRole() {
+      mockMvc
+          .delete("/configs/userroles/42") {
+            with(user("admin").roles("ADMIN"))
+            accept(MediaType.TEXT_HTML)
+          }
+          .andExpect {
+            status { is2xxSuccessful() }
+            view { name("configs/userroles") }
+          }
 
-            assertThat(captor.firstValue).isEqualTo(42)
-        }
+      val captor = argumentCaptor<Long>()
+      verify(userRoleService, times(1)).deleteUserRole(captor.capture())
 
-        @Test
-        fun testShouldUpdateUserRole() {
-            mockMvc.put("/configs/userroles/42") {
-                with(user("admin").roles("ADMIN"))
-                accept(MediaType.TEXT_HTML)
-                contentType = MediaType.APPLICATION_FORM_URLENCODED
-                content = "role=ADMIN"
-            }.andExpect {
-                status { is2xxSuccessful() }
-                view { name("configs/userroles") }
-            }
-
-            val idCaptor = argumentCaptor<Long>()
-            val roleCaptor = argumentCaptor<Role>()
-            verify(userRoleService, times(1)).updateUserRole(
-                idCaptor.capture(),
-                roleCaptor.capture()
-            )
-
-            assertThat(idCaptor.firstValue).isEqualTo(42)
-            assertThat(roleCaptor.firstValue).isEqualTo(Role.ADMIN)
-        }
+      assertThat(captor.firstValue).isEqualTo(42)
+    }
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldRenderConfigPageWithUserRoles() {
-            val page = webClient.getPage<HtmlPage>("http://localhost/configs")
-            assertThat(
-                page.getElementById("userroles")
-            ).isNotNull
-        }
+    @Test
+    fun testShouldUpdateUserRole() {
+      mockMvc
+          .put("/configs/userroles/42") {
+            with(user("admin").roles("ADMIN"))
+            accept(MediaType.TEXT_HTML)
+            contentType = MediaType.APPLICATION_FORM_URLENCODED
+            content = "role=ADMIN"
+          }
+          .andExpect {
+            status { is2xxSuccessful() }
+            view { name("configs/userroles") }
+          }
+
+      val idCaptor = argumentCaptor<Long>()
+      val roleCaptor = argumentCaptor<Role>()
+      verify(userRoleService, times(1)).updateUserRole(idCaptor.capture(), roleCaptor.capture())
+
+      assertThat(idCaptor.firstValue).isEqualTo(42)
+      assertThat(roleCaptor.firstValue).isEqualTo(Role.ADMIN)
     }
 
-    @Nested
-    inner class WithUserRolesDisabled {
-        @BeforeEach
-        fun setup() {
-            webClient.options.isThrowExceptionOnScriptError = false
-        }
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldRenderConfigPageWithUserRoles() {
+      val page = webClient.getPage<HtmlPage>("http://localhost/configs")
+      assertThat(page.getElementById("userroles")).isNotNull
+    }
+  }
 
-        @Test
-        fun testShouldRenderConfigPageWithoutUserRoles() {
-            val page = webClient.getPage<HtmlPage>("http://localhost/configs")
-            assertThat(
-                page.getElementById("userroles")
-            ).isNull()
-        }
+  @Nested
+  inner class WithUserRolesDisabled {
+    @BeforeEach
+    fun setup() {
+      webClient.options.isThrowExceptionOnScriptError = false
     }
 
-    @Nested
-    inner class SseTest {
-        private lateinit var webClient: WebTestClient
+    @Test
+    fun testShouldRenderConfigPageWithoutUserRoles() {
+      val page = webClient.getPage<HtmlPage>("http://localhost/configs")
+      assertThat(page.getElementById("userroles")).isNull()
+    }
+  }
 
-        @BeforeEach
-        fun setup(
-            applicationContext: WebApplicationContext
-        ) {
-            this.webClient = MockMvcWebTestClient
-                .bindToApplicationContext(applicationContext).build()
-        }
+  @Nested
+  inner class SseTest {
+    private lateinit var webClient: WebTestClient
 
-        @Test
-        fun testShouldRequestGPasSSE() {
-            val expectedEvent =
-                ConnectionCheckResult.GPasConnectionCheckResult(true, Instant.now(), Instant.now())
-
-            connectionCheckUpdateProducer.tryEmitNext(expectedEvent)
-            connectionCheckUpdateProducer.emitComplete { _, _ -> true }
-
-            val result =
-                webClient.get().uri("http://localhost/configs/events").accept(TEXT_EVENT_STREAM)
-                    .exchange()
-                    .expectStatus().isOk()
-                    .expectHeader().contentType(TEXT_EVENT_STREAM)
-                    .returnResult(ConnectionCheckResult.GPasConnectionCheckResult::class.java)
-
-            StepVerifier.create(result.responseBody)
-                .expectNext(expectedEvent)
-                .expectComplete()
-                .verify()
-        }
+    @BeforeEach
+    fun setup(applicationContext: WebApplicationContext) {
+      this.webClient = MockMvcWebTestClient.bindToApplicationContext(applicationContext).build()
     }
 
+    @Test
+    fun testShouldRequestGPasSSE() {
+      val expectedEvent =
+          ConnectionCheckResult.GPasConnectionCheckResult(true, Instant.now(), Instant.now())
+
+      connectionCheckUpdateProducer.tryEmitNext(expectedEvent)
+      connectionCheckUpdateProducer.emitComplete { _, _ -> true }
+
+      val result =
+          webClient
+              .get()
+              .uri("http://localhost/configs/events")
+              .accept(TEXT_EVENT_STREAM)
+              .exchange()
+              .expectStatus()
+              .isOk()
+              .expectHeader()
+              .contentType(TEXT_EVENT_STREAM)
+              .returnResult(ConnectionCheckResult.GPasConnectionCheckResult::class.java)
+
+      StepVerifier.create(result.responseBody).expectNext(expectedEvent).expectComplete().verify()
+    }
+  }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/HomeControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/HomeControllerTest.kt
index 628112c..33fc9d2 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/HomeControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/HomeControllerTest.kt
@@ -27,6 +27,9 @@ import dev.dnpm.etl.processor.monitoring.Request
 import dev.dnpm.etl.processor.monitoring.RequestStatus
 import dev.dnpm.etl.processor.monitoring.RequestType
 import dev.dnpm.etl.processor.services.RequestService
+import java.io.IOException
+import java.time.Instant
+import java.util.*
 import org.assertj.core.api.Assertions.assertThat
 import org.htmlunit.WebClient
 import org.htmlunit.html.HtmlPage
@@ -51,261 +54,248 @@ import org.springframework.test.context.junit.jupiter.SpringExtension
 import org.springframework.test.web.servlet.MockMvc
 import org.springframework.test.web.servlet.get
 import org.springframework.test.web.servlet.htmlunit.MockMvcWebClientBuilder
-import java.io.IOException
-import java.time.Instant
-import java.util.*
 
 @WebMvcTest(controllers = [HomeController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        HomeController::class,
-        AppConfiguration::class,
-        AppSecurityConfiguration::class
-    ]
+    classes = [HomeController::class, AppConfiguration::class, AppSecurityConfiguration::class]
 )
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-        "app.security.admin-user=admin",
-        "app.security.admin-password={noop}very-secret"
-    ]
-)
-@MockitoBean(
-    types = [RequestService::class]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+            "app.security.admin-user=admin",
+            "app.security.admin-password={noop}very-secret",
+        ]
 )
+@MockitoBean(types = [RequestService::class])
 class HomeControllerTest {
 
-    private lateinit var mockMvc: MockMvc
-    private lateinit var webClient: WebClient
+  private lateinit var mockMvc: MockMvc
+  private lateinit var webClient: WebClient
 
-    @BeforeEach
-    fun setup(
-        @Autowired mockMvc: MockMvc,
-        @Autowired requestService: RequestService
-    ) {
-        this.mockMvc = mockMvc
-        this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
+  @BeforeEach
+  fun setup(@Autowired mockMvc: MockMvc, @Autowired requestService: RequestService) {
+    this.mockMvc = mockMvc
+    this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
 
-        whenever(requestService.findAll(any<Pageable>())).thenReturn(Page.empty())
-    }
+    whenever(requestService.findAll(any<Pageable>())).thenReturn(Page.empty())
+  }
 
-    @Test
-    fun testShouldRequestHomePage() {
-        mockMvc.get("/").andExpect {
-            status { isOk() }
-            view { name("index") }
-        }
+  @Test
+  fun testShouldRequestHomePage() {
+    mockMvc.get("/").andExpect {
+      status { isOk() }
+      view { name("index") }
     }
+  }
 
-    @Nested
-    inner class WithRequests {
-
-        private lateinit var requestService: RequestService
-
-        @BeforeEach
-        fun setup(
-            @Autowired requestService: RequestService
-        ) {
-            this.requestService = requestService
-        }
-
-        @Test
-        fun testShouldShowHomePage() {
-            whenever(requestService.findAll(any<Pageable>())).thenReturn(
-                PageImpl(
-                    listOf(
-                        Request(
-                            2L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("ashdkasdh"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.SUCCESS
-                        ),
-                        Request(
-                            1L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("asdasdasd"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.ERROR
-                        )
-                    )
-                )
-            )
-
-            val page = webClient.getPage<HtmlPage>("http://localhost/")
-            assertThat(page.querySelectorAll("tbody tr")).hasSize(2)
-            assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
-        }
-
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldShowRequestDetails() {
-            val requestId = randomRequestId()
-
-            whenever(requestService.findByUuid(anyValueClass())).thenReturn(
-                Optional.of(
-                    Request(
-                        2L,
-                        requestId,
-                        PatientPseudonym("PSEUDO1"),
-                        PatientId("PATIENT1"),
-                        Fingerprint("ashdkasdh"),
-                        RequestType.MTB_FILE,
-                        RequestStatus.SUCCESS,
-                        Instant.now(),
-                        Report("Test")
-                    )
-                )
-            )
-
-            val page = webClient.getPage<HtmlPage>("http://localhost/report/${requestId.value}")
-            assertThat(page.querySelectorAll("tbody tr")).hasSize(1)
-            assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
-        }
-
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldShowPatientDetails() {
-            whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>())).thenReturn(
-                PageImpl(
-                    listOf(
-                        Request(
-                            2L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("ashdkasdh"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.SUCCESS
-                        ),
-                        Request(
-                            1L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("asdasdasd"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.ERROR
-                        )
-                    )
-                )
-            )
-
-            val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
-            assertThat(page.querySelectorAll("tbody tr")).hasSize(2)
-            assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
-        }
+  @Nested
+  inner class WithRequests {
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldShowPatientPseudonym() {
-            whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>())).thenReturn(
-                PageImpl(
-                    listOf(
-                        Request(
-                            2L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("ashdkasdh"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.SUCCESS
-                        ),
-                        Request(
-                            1L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("asdasdasd"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.ERROR
-                        )
-                    )
-                )
-            )
+    private lateinit var requestService: RequestService
 
-            val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
-            assertThat(page.querySelectorAll("h2 > span")).hasSize(1)
-            assertThat(page.querySelectorAll("h2 > span").first().textContent).isEqualTo("PSEUDO1")
-        }
+    @BeforeEach
+    fun setup(@Autowired requestService: RequestService) {
+      this.requestService = requestService
+    }
 
+    @Test
+    fun testShouldShowHomePage() {
+      whenever(requestService.findAll(any<Pageable>()))
+          .thenReturn(
+              PageImpl(
+                  listOf(
+                      Request(
+                          2L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("ashdkasdh"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.SUCCESS,
+                      ),
+                      Request(
+                          1L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("asdasdasd"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.ERROR,
+                      ),
+                  )
+              )
+          )
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/")
+      assertThat(page.querySelectorAll("tbody tr")).hasSize(2)
+      assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
     }
 
-    @Nested
-    inner class WithoutRequests {
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldShowRequestDetails() {
+      val requestId = randomRequestId()
+
+      whenever(requestService.findByUuid(anyValueClass()))
+          .thenReturn(
+              Optional.of(
+                  Request(
+                      2L,
+                      requestId,
+                      PatientPseudonym("PSEUDO1"),
+                      PatientId("PATIENT1"),
+                      Fingerprint("ashdkasdh"),
+                      RequestType.MTB_FILE,
+                      RequestStatus.SUCCESS,
+                      Instant.now(),
+                      Report("Test"),
+                  )
+              )
+          )
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/report/${requestId.value}")
+      assertThat(page.querySelectorAll("tbody tr")).hasSize(1)
+      assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
+    }
 
-        private lateinit var requestService: RequestService
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldShowPatientDetails() {
+      whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>()))
+          .thenReturn(
+              PageImpl(
+                  listOf(
+                      Request(
+                          2L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("ashdkasdh"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.SUCCESS,
+                      ),
+                      Request(
+                          1L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("asdasdasd"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.ERROR,
+                      ),
+                  )
+              )
+          )
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
+      assertThat(page.querySelectorAll("tbody tr")).hasSize(2)
+      assertThat(page.querySelectorAll("div.notification.info")).isEmpty()
+    }
 
-        @BeforeEach
-        fun setup(
-            @Autowired requestService: RequestService
-        ) {
-            this.requestService = requestService
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldShowPatientPseudonym() {
+      whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>()))
+          .thenReturn(
+              PageImpl(
+                  listOf(
+                      Request(
+                          2L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("ashdkasdh"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.SUCCESS,
+                      ),
+                      Request(
+                          1L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("asdasdasd"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.ERROR,
+                      ),
+                  )
+              )
+          )
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
+      assertThat(page.querySelectorAll("h2 > span")).hasSize(1)
+      assertThat(page.querySelectorAll("h2 > span").first().textContent).isEqualTo("PSEUDO1")
+    }
+  }
 
-            whenever(requestService.findAll(any<Pageable>())).thenReturn(Page.empty())
-        }
+  @Nested
+  inner class WithoutRequests {
 
-        @Test
-        fun testShouldShowHomePage() {
-            val page = webClient.getPage<HtmlPage>("http://localhost/")
-            assertThat(page.querySelectorAll("tbody tr")).isEmpty()
-            assertThat(page.querySelectorAll("div.notification.info")).hasSize(1)
-        }
+    private lateinit var requestService: RequestService
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldThrowNotFoundExceptionForUnknownReport() {
-            val requestId = randomRequestId()
+    @BeforeEach
+    fun setup(@Autowired requestService: RequestService) {
+      this.requestService = requestService
 
-            whenever(requestService.findByUuid(anyValueClass())).thenReturn(
-                Optional.empty()
-            )
+      whenever(requestService.findAll(any<Pageable>())).thenReturn(Page.empty())
+    }
 
-            assertThrows<IOException> {
-                webClient.getPage<HtmlPage>("http://localhost/report/${requestId.value}")
-            }.also {
-                assertThat(it).hasRootCauseInstanceOf(NotFoundException::class.java)
-            }
-        }
+    @Test
+    fun testShouldShowHomePage() {
+      val page = webClient.getPage<HtmlPage>("http://localhost/")
+      assertThat(page.querySelectorAll("tbody tr")).isEmpty()
+      assertThat(page.querySelectorAll("div.notification.info")).hasSize(1)
+    }
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldShowEmptyPatientDetails() {
-            whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>())).thenReturn(Page.empty())
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldThrowNotFoundExceptionForUnknownReport() {
+      val requestId = randomRequestId()
 
-            val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
-            assertThat(page.querySelectorAll("tbody tr")).isEmpty()
-            assertThat(page.querySelectorAll("div.notification.info")).hasSize(1)
-        }
+      whenever(requestService.findByUuid(anyValueClass())).thenReturn(Optional.empty())
 
-        @Test
-        @WithMockUser(username = "admin", roles = ["ADMIN"])
-        fun testShouldShowNoConsentStatusBadge() {
-            whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>())).thenReturn(
-                PageImpl(
-                    listOf(
-                        Request(
-                            1L,
-                            randomRequestId(),
-                            PatientPseudonym("PSEUDO1"),
-                            PatientId("PATIENT1"),
-                            Fingerprint("ashdkasdh"),
-                            RequestType.MTB_FILE,
-                            RequestStatus.NO_CONSENT
-                        )
-                    )
-                )
-            )
+      assertThrows<IOException> {
+            webClient.getPage<HtmlPage>("http://localhost/report/${requestId.value}")
+          }
+          .also { assertThat(it).hasRootCauseInstanceOf(NotFoundException::class.java) }
+    }
 
-            val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
-            assertThat(page.querySelectorAll("tbody tr")).hasSize(1)
-            assertThat(page.querySelectorAll("tbody tr > td > small").first().textContent).isEqualTo("NO_CONSENT")
-        }
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldShowEmptyPatientDetails() {
+      whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>()))
+          .thenReturn(Page.empty())
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
+      assertThat(page.querySelectorAll("tbody tr")).isEmpty()
+      assertThat(page.querySelectorAll("div.notification.info")).hasSize(1)
     }
 
+    @Test
+    @WithMockUser(username = "admin", roles = ["ADMIN"])
+    fun testShouldShowNoConsentStatusBadge() {
+      whenever(requestService.findRequestByPatientId(anyValueClass(), any<Pageable>()))
+          .thenReturn(
+              PageImpl(
+                  listOf(
+                      Request(
+                          1L,
+                          randomRequestId(),
+                          PatientPseudonym("PSEUDO1"),
+                          PatientId("PATIENT1"),
+                          Fingerprint("ashdkasdh"),
+                          RequestType.MTB_FILE,
+                          RequestStatus.NO_CONSENT,
+                      )
+                  )
+              )
+          )
+
+      val page = webClient.getPage<HtmlPage>("http://localhost/patient/PSEUDO1")
+      assertThat(page.querySelectorAll("tbody tr")).hasSize(1)
+      assertThat(page.querySelectorAll("tbody tr > td > small").first().textContent)
+          .isEqualTo("NO_CONSENT")
+    }
+  }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/LoginControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/LoginControllerTest.kt
index 54ad6e8..bd8014a 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/LoginControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/LoginControllerTest.kt
@@ -42,30 +42,26 @@ import org.springframework.test.web.servlet.htmlunit.MockMvcWebClientBuilder
 @WebMvcTest(controllers = [LoginController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        LoginController::class,
-        AppConfiguration::class,
-        AppSecurityConfiguration::class
-    ]
+    classes = [LoginController::class, AppConfiguration::class, AppSecurityConfiguration::class],
 )
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-        "app.security.admin-user=admin",
-        "app.security.admin-password={noop}very-secret",
-        "app.security.enable-tokens=true"
-    ]
-)
-@MockitoBean(
-    types = [TokenService::class]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+            "app.security.admin-user=admin",
+            "app.security.admin-password={noop}very-secret",
+            "app.security.enable-tokens=true",
+        ],
 )
+@MockitoBean(types = [TokenService::class])
 class LoginControllerTest {
-
     private lateinit var mockMvc: MockMvc
     private lateinit var webClient: WebClient
 
     @BeforeEach
-    fun setup(@Autowired mockMvc: MockMvc) {
+    fun setup(
+        @Autowired mockMvc: MockMvc,
+    ) {
         this.mockMvc = mockMvc
         this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
     }
@@ -82,7 +78,11 @@ class LoginControllerTest {
     fun testShouldShowLoginForm() {
         val page = webClient.getPage<HtmlPage>("http://localhost/login")
         assertThat(
-            page.getElementsByTagName("main").first().firstElementChild.getAttribute("class")
+            page
+                .getElementsByTagName("main")
+                .first()
+                .firstElementChild
+                .getAttribute("class"),
         ).isEqualTo("login-form")
     }
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsControllerTest.kt
index b55a702..f91e3cf 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsControllerTest.kt
@@ -38,26 +38,25 @@ import org.springframework.test.web.servlet.htmlunit.MockMvcWebClientBuilder
 @WebMvcTest(controllers = [StatisticsController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        StatisticsController::class,
-        AppConfiguration::class,
-        AppSecurityConfiguration::class
-    ]
+    classes =
+        [StatisticsController::class, AppConfiguration::class, AppSecurityConfiguration::class],
 )
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-        "app.security.admin-user=admin",
-        "app.security.admin-password={noop}very-secret"
-    ]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+            "app.security.admin-user=admin",
+            "app.security.admin-password={noop}very-secret",
+        ],
 )
 class StatisticsControllerTest {
-
     private lateinit var mockMvc: MockMvc
     private lateinit var webClient: WebClient
 
     @BeforeEach
-    fun setup(@Autowired mockMvc: MockMvc) {
+    fun setup(
+        @Autowired mockMvc: MockMvc,
+    ) {
         this.mockMvc = mockMvc
         this.webClient = MockMvcWebClientBuilder.mockMvcSetup(mockMvc).build()
     }
@@ -69,5 +68,4 @@ class StatisticsControllerTest {
             view { name("statistics") }
         }
     }
-
 }
diff --git a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsRestControllerTest.kt b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsRestControllerTest.kt
index f0c3b63..16a9464 100644
--- a/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsRestControllerTest.kt
+++ b/src/integrationTest/kotlin/dev/dnpm/etl/processor/web/StatisticsRestControllerTest.kt
@@ -57,28 +57,22 @@ import java.time.Instant
 import java.time.ZoneId
 import java.time.temporal.ChronoUnit
 
-
 @WebMvcTest(controllers = [StatisticsRestController::class])
 @ExtendWith(value = [MockitoExtension::class, SpringExtension::class])
 @ContextConfiguration(
-    classes = [
-        StatisticsRestController::class,
-        AppConfiguration::class,
-        AppSecurityConfiguration::class
-    ]
+    classes =
+        [StatisticsRestController::class, AppConfiguration::class, AppSecurityConfiguration::class],
 )
 @TestPropertySource(
-    properties = [
-        "app.pseudonymize.generator=BUILDIN",
-        "app.security.admin-user=admin",
-        "app.security.admin-password={noop}very-secret"
-    ]
-)
-@MockitoBean(
-    types = [RequestService::class]
+    properties =
+        [
+            "app.pseudonymize.generator=BUILDIN",
+            "app.security.admin-user=admin",
+            "app.security.admin-password={noop}very-secret",
+        ],
 )
+@MockitoBean(types = [RequestService::class])
 class StatisticsRestControllerTest {
-
     private lateinit var mockMvc: MockMvc
 
     private lateinit var statisticsUpdateProducer: Sinks.Many<Any>
@@ -88,7 +82,7 @@ class StatisticsRestControllerTest {
     fun setup(
         @Autowired mockMvc: MockMvc,
         @Autowired statisticsUpdateProducer: Sinks.Many<Any>,
-        @Autowired requestService: RequestService
+        @Autowired requestService: RequestService,
     ) {
         this.mockMvc = mockMvc
         this.statisticsUpdateProducer = statisticsUpdateProducer
@@ -100,40 +94,38 @@ class StatisticsRestControllerTest {
         @Test
         fun testShouldRequestStatesForMtbFiles() {
             doAnswer { _ ->
-                listOf(
-                    CountedState(42, RequestStatus.WARNING),
-                    CountedState(1, RequestStatus.UNKNOWN)
-                )
-            }.whenever(requestService).countStates()
+                listOf(CountedState(42, RequestStatus.WARNING), CountedState(1, RequestStatus.UNKNOWN))
+            }.whenever(requestService)
+                .countStates()
 
             mockMvc.get("/statistics/requeststates").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(2))
-                    jsonPath("$[0].name", equalTo(RequestStatus.WARNING.name))
-                    jsonPath("$[0].value", equalTo(42))
-                    jsonPath("$[1].name", equalTo(RequestStatus.UNKNOWN.name))
-                    jsonPath("$[1].value", equalTo(1))
-                }
+                status { isOk() }
+                    .also {
+                        jsonPath("$", hasSize<Int>(2))
+                        jsonPath("$[0].name", equalTo(RequestStatus.WARNING.name))
+                        jsonPath("$[0].value", equalTo(42))
+                        jsonPath("$[1].name", equalTo(RequestStatus.UNKNOWN.name))
+                        jsonPath("$[1].value", equalTo(1))
+                    }
             }
         }
 
         @Test
         fun testShouldRequestStatesForDeletes() {
             doAnswer { _ ->
-                listOf(
-                    CountedState(42, RequestStatus.SUCCESS),
-                    CountedState(1, RequestStatus.ERROR)
-                )
-            }.whenever(requestService).countDeleteStates()
+                listOf(CountedState(42, RequestStatus.SUCCESS), CountedState(1, RequestStatus.ERROR))
+            }.whenever(requestService)
+                .countDeleteStates()
 
             mockMvc.get("/statistics/requeststates?delete=true").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(2))
-                    jsonPath("$[0].name", equalTo(RequestStatus.SUCCESS.name))
-                    jsonPath("$[0].value", equalTo(42))
-                    jsonPath("$[1].name", equalTo(RequestStatus.ERROR.name))
-                    jsonPath("$[1].value", equalTo(1))
-                }
+                status { isOk() }
+                    .also {
+                        jsonPath("$", hasSize<Int>(2))
+                        jsonPath("$[0].name", equalTo(RequestStatus.SUCCESS.name))
+                        jsonPath("$[0].value", equalTo(42))
+                        jsonPath("$[1].name", equalTo(RequestStatus.ERROR.name))
+                        jsonPath("$[1].value", equalTo(1))
+                    }
             }
         }
     }
@@ -143,47 +135,44 @@ class StatisticsRestControllerTest {
         @Test
         fun testShouldRequestPatientStatesForMtbFiles() {
             doAnswer { _ ->
-                listOf(
-                    CountedState(42, RequestStatus.WARNING),
-                    CountedState(1, RequestStatus.UNKNOWN)
-                )
-            }.whenever(requestService).findPatientUniqueStates()
+                listOf(CountedState(42, RequestStatus.WARNING), CountedState(1, RequestStatus.UNKNOWN))
+            }.whenever(requestService)
+                .findPatientUniqueStates()
 
             mockMvc.get("/statistics/requestpatientstates").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(2))
-                    jsonPath("$[0].name", equalTo(RequestStatus.WARNING.name))
-                    jsonPath("$[0].value", equalTo(42))
-                    jsonPath("$[1].name", equalTo(RequestStatus.UNKNOWN.name))
-                    jsonPath("$[1].value", equalTo(1))
-                }
+                status { isOk() }
+                    .also {
+                        jsonPath("$", hasSize<Int>(2))
+                        jsonPath("$[0].name", equalTo(RequestStatus.WARNING.name))
+                        jsonPath("$[0].value", equalTo(42))
+                        jsonPath("$[1].name", equalTo(RequestStatus.UNKNOWN.name))
+                        jsonPath("$[1].value", equalTo(1))
+                    }
             }
         }
 
         @Test
         fun testShouldRequestPatientStatesForDeletes() {
             doAnswer { _ ->
-                listOf(
-                    CountedState(42, RequestStatus.SUCCESS),
-                    CountedState(1, RequestStatus.ERROR)
-                )
-            }.whenever(requestService).findPatientUniqueDeleteStates()
+                listOf(CountedState(42, RequestStatus.SUCCESS), CountedState(1, RequestStatus.ERROR))
+            }.whenever(requestService)
+                .findPatientUniqueDeleteStates()
 
             mockMvc.get("/statistics/requestpatientstates?delete=true").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(2))
-                    jsonPath("$[0].name", equalTo(RequestStatus.SUCCESS.name))
-                    jsonPath("$[0].value", equalTo(42))
-                    jsonPath("$[1].name", equalTo(RequestStatus.ERROR.name))
-                    jsonPath("$[1].value", equalTo(1))
-                }
+                status { isOk() }
+                    .also {
+                        jsonPath("$", hasSize<Int>(2))
+                        jsonPath("$[0].name", equalTo(RequestStatus.SUCCESS.name))
+                        jsonPath("$[0].value", equalTo(42))
+                        jsonPath("$[1].name", equalTo(RequestStatus.ERROR.name))
+                        jsonPath("$[1].value", equalTo(1))
+                    }
             }
         }
     }
 
     @Nested
     inner class LastMonthStatesTest {
-
         @BeforeEach
         fun setup() {
             val zoneId = ZoneId.of("Europe/Berlin")
@@ -197,7 +186,12 @@ class StatisticsRestControllerTest {
                         Fingerprint("0123456789abcdef1"),
                         RequestType.MTB_FILE,
                         RequestStatus.SUCCESS,
-                        Instant.now().atZone(zoneId).truncatedTo(ChronoUnit.DAYS).minus(2, ChronoUnit.DAYS).toInstant()
+                        Instant
+                            .now()
+                            .atZone(zoneId)
+                            .truncatedTo(ChronoUnit.DAYS)
+                            .minus(2, ChronoUnit.DAYS)
+                            .toInstant(),
                     ),
                     Request(
                         2,
@@ -207,7 +201,12 @@ class StatisticsRestControllerTest {
                         Fingerprint("0123456789abcdef2"),
                         RequestType.MTB_FILE,
                         RequestStatus.WARNING,
-                        Instant.now().atZone(zoneId).truncatedTo(ChronoUnit.DAYS).minus(2, ChronoUnit.DAYS).toInstant()
+                        Instant
+                            .now()
+                            .atZone(zoneId)
+                            .truncatedTo(ChronoUnit.DAYS)
+                            .minus(2, ChronoUnit.DAYS)
+                            .toInstant(),
                     ),
                     Request(
                         3,
@@ -217,7 +216,12 @@ class StatisticsRestControllerTest {
                         Fingerprint("0123456789abcdee1"),
                         RequestType.DELETE,
                         RequestStatus.ERROR,
-                        Instant.now().atZone(zoneId).truncatedTo(ChronoUnit.DAYS).minus(1, ChronoUnit.DAYS).toInstant()
+                        Instant
+                            .now()
+                            .atZone(zoneId)
+                            .truncatedTo(ChronoUnit.DAYS)
+                            .minus(1, ChronoUnit.DAYS)
+                            .toInstant(),
                     ),
                     Request(
                         4,
@@ -227,7 +231,12 @@ class StatisticsRestControllerTest {
                         Fingerprint("0123456789abcdef2"),
                         RequestType.MTB_FILE,
                         RequestStatus.DUPLICATION,
-                        Instant.now().atZone(zoneId).truncatedTo(ChronoUnit.DAYS).minus(1, ChronoUnit.DAYS).toInstant()
+                        Instant
+                            .now()
+                            .atZone(zoneId)
+                            .truncatedTo(ChronoUnit.DAYS)
+                            .minus(1, ChronoUnit.DAYS)
+                            .toInstant(),
                     ),
                     Request(
                         5,
@@ -237,49 +246,54 @@ class StatisticsRestControllerTest {
                         Fingerprint("0123456789abcdef2"),
                         RequestType.DELETE,
                         RequestStatus.UNKNOWN,
-                        Instant.now().atZone(zoneId).truncatedTo(ChronoUnit.DAYS).toInstant()
+                        Instant
+                            .now()
+                            .atZone(zoneId)
+                            .truncatedTo(ChronoUnit.DAYS)
+                            .toInstant(),
                     ),
                 )
-            }.whenever(requestService).findAll()
+            }.whenever(requestService)
+                .findAll()
         }
 
         @Test
         fun testShouldRequestLastMonthForMtbFiles() {
             mockMvc.get("/statistics/requestslastmonth").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(31))
-                }.also {
-                    jsonPath("$[28].nameValues.error", equalTo(0))
-                    jsonPath("$[28].nameValues.warning", equalTo(1))
-                    jsonPath("$[28].nameValues.success", equalTo(1))
-                    jsonPath("$[28].nameValues.duplication", equalTo(0))
-                    jsonPath("$[28].nameValues.unknown", equalTo(0))
-                    jsonPath("$[29].nameValues.error", equalTo(0))
-                    jsonPath("$[29].nameValues.warning", equalTo(0))
-                    jsonPath("$[29].nameValues.success", equalTo(0))
-                    jsonPath("$[29].nameValues.duplication", equalTo(1))
-                    jsonPath("$[29].nameValues.unknown", equalTo(0))
-                }
+                status { isOk() }
+                    .also { jsonPath("$", hasSize<Int>(31)) }
+                    .also {
+                        jsonPath("$[28].nameValues.error", equalTo(0))
+                        jsonPath("$[28].nameValues.warning", equalTo(1))
+                        jsonPath("$[28].nameValues.success", equalTo(1))
+                        jsonPath("$[28].nameValues.duplication", equalTo(0))
+                        jsonPath("$[28].nameValues.unknown", equalTo(0))
+                        jsonPath("$[29].nameValues.error", equalTo(0))
+                        jsonPath("$[29].nameValues.warning", equalTo(0))
+                        jsonPath("$[29].nameValues.success", equalTo(0))
+                        jsonPath("$[29].nameValues.duplication", equalTo(1))
+                        jsonPath("$[29].nameValues.unknown", equalTo(0))
+                    }
             }
         }
 
         @Test
         fun testShouldRequestLastMonthForDeletes() {
             mockMvc.get("/statistics/requestslastmonth?delete=true").andExpect {
-                status { isOk() }.also {
-                    jsonPath("$", hasSize<Int>(31))
-                }.also {
-                    jsonPath("$[29].nameValues.error", equalTo(1))
-                    jsonPath("$[29].nameValues.warning", equalTo(0))
-                    jsonPath("$[29].nameValues.success", equalTo(0))
-                    jsonPath("$[29].nameValues.duplication", equalTo(0))
-                    jsonPath("$[29].nameValues.unknown", equalTo(0))
-                    jsonPath("$[30].nameValues.error", equalTo(0))
-                    jsonPath("$[30].nameValues.warning", equalTo(0))
-                    jsonPath("$[30].nameValues.success", equalTo(0))
-                    jsonPath("$[30].nameValues.duplication", equalTo(0))
-                    jsonPath("$[30].nameValues.unknown", equalTo(1))
-                }
+                status { isOk() }
+                    .also { jsonPath("$", hasSize<Int>(31)) }
+                    .also {
+                        jsonPath("$[29].nameValues.error", equalTo(1))
+                        jsonPath("$[29].nameValues.warning", equalTo(0))
+                        jsonPath("$[29].nameValues.success", equalTo(0))
+                        jsonPath("$[29].nameValues.duplication", equalTo(0))
+                        jsonPath("$[29].nameValues.unknown", equalTo(0))
+                        jsonPath("$[30].nameValues.error", equalTo(0))
+                        jsonPath("$[30].nameValues.warning", equalTo(0))
+                        jsonPath("$[30].nameValues.success", equalTo(0))
+                        jsonPath("$[30].nameValues.duplication", equalTo(0))
+                        jsonPath("$[30].nameValues.unknown", equalTo(1))
+                    }
             }
         }
     }
@@ -289,26 +303,27 @@ class StatisticsRestControllerTest {
         private lateinit var webClient: WebTestClient
 
         @BeforeEach
-        fun setup(
-            applicationContext: WebApplicationContext,
-        ) {
-            this.webClient = MockMvcWebTestClient
-                .bindToApplicationContext(applicationContext).build()
+        fun setup(applicationContext: WebApplicationContext) {
+            this.webClient = MockMvcWebTestClient.bindToApplicationContext(applicationContext).build()
         }
 
         @Test
         fun testShouldRequestSSE() {
             statisticsUpdateProducer.emitComplete { _, _ -> true }
 
-            val result = webClient.get().uri("http://localhost/statistics/events").accept(TEXT_EVENT_STREAM).exchange()
-                .expectStatus().isOk()
-                .expectHeader().contentType(TEXT_EVENT_STREAM)
-                .returnResult(String::class.java)
+            val result =
+                webClient
+                    .get()
+                    .uri("http://localhost/statistics/events")
+                    .accept(TEXT_EVENT_STREAM)
+                    .exchange()
+                    .expectStatus()
+                    .isOk()
+                    .expectHeader()
+                    .contentType(TEXT_EVENT_STREAM)
+                    .returnResult(String::class.java)
 
-            StepVerifier.create(result.responseBody)
-                .expectComplete()
-                .verify()
+            StepVerifier.create(result.responseBody).expectComplete().verify()
         }
     }
-
 }