test: add check result emit tests (#168)

1 files changed, 145 insertions, 16 deletions

diff --git a/src/test/kotlin/dev/dnpm/etl/processor/monitoring/ConnectionCheckServiceTest.kt b/src/test/kotlin/dev/dnpm/etl/processor/monitoring/ConnectionCheckServiceTest.kt
index 7205714..d34d2b8 100644
--- a/src/test/kotlin/dev/dnpm/etl/processor/monitoring/ConnectionCheckServiceTest.kt
+++ b/src/test/kotlin/dev/dnpm/etl/processor/monitoring/ConnectionCheckServiceTest.kt
@@ -3,20 +3,22 @@ package dev.dnpm.etl.processor.monitoring
 import dev.dnpm.etl.processor.config.GIcsConfigProperties
 import dev.dnpm.etl.processor.config.GPasConfigProperties
 import dev.dnpm.etl.processor.config.RestTargetProperties
+import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
-import org.mockito.Mock
 import org.mockito.junit.jupiter.MockitoExtension
 import org.springframework.http.HttpMethod
 import org.springframework.http.MediaType
 import org.springframework.test.web.client.MockRestServiceServer
 import org.springframework.test.web.client.match.MockRestRequestMatchers.method
 import org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo
+import org.springframework.test.web.client.response.MockRestResponseCreators.withServerError
 import org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess
 import org.springframework.web.client.RestTemplate
 import reactor.core.publisher.Sinks
+import reactor.test.StepVerifier
 
 @ExtendWith(MockitoExtension::class)
 class ConnectionCheckServiceTest {
@@ -26,19 +28,18 @@ class ConnectionCheckServiceTest {
 
         lateinit var mockRestServiceServer: MockRestServiceServer
         lateinit var service: RestConnectionCheckService
+        lateinit var sink: Sinks.Many<ConnectionCheckResult>
 
         @BeforeEach
-        fun setUp(
-            @Mock sink: Sinks.Many<ConnectionCheckResult>
-        ) {
+        fun setUp() {
             val restTemplate = RestTemplate()
-            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
-
             val restTargetProperties = RestTargetProperties(
                 "http://localhost/api",
                 "user",
                 "password",
             )
+            this.sink = Sinks.many().multicast().onBackpressureBuffer()
+            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
 
             this.service = RestConnectionCheckService(restTemplate, restTargetProperties, sink)
         }
@@ -53,9 +54,51 @@ class ConnectionCheckServiceTest {
                 )
 
             this.service.check()
-
             this.mockRestServiceServer.verify()
+        }
 
+        @Test
+        fun shouldEmitAvailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withSuccess("OK", MediaType.APPLICATION_JSON),
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isTrue()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
+
+            verifier.verify()
+        }
+
+        @Test
+        fun shouldEmitUnavailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withServerError()
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isFalse()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
+
+            verifier.verify()
         }
     }
 
@@ -64,14 +107,11 @@ class ConnectionCheckServiceTest {
 
         lateinit var mockRestServiceServer: MockRestServiceServer
         lateinit var service: GPasConnectionCheckService
+        lateinit var sink: Sinks.Many<ConnectionCheckResult>
 
         @BeforeEach
-        fun setUp(
-            @Mock sink: Sinks.Many<ConnectionCheckResult>
-        ) {
+        fun setUp() {
             val restTemplate = RestTemplate()
-            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
-
             val gpasTargetProperties = GPasConfigProperties(
                 "http://localhost/gpas",
                 null,
@@ -80,6 +120,8 @@ class ConnectionCheckServiceTest {
                 "username",
                 "password",
             )
+            this.sink = Sinks.many().multicast().onBackpressureBuffer()
+            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
 
             this.service = GPasConnectionCheckService(restTemplate, gpasTargetProperties, sink)
         }
@@ -96,7 +138,50 @@ class ConnectionCheckServiceTest {
             this.service.check()
 
             this.mockRestServiceServer.verify()
+        }
+
+        @Test
+        fun shouldEmitAvailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withSuccess("OK", MediaType.APPLICATION_JSON),
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isTrue()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
 
+            verifier.verify()
+        }
+
+        @Test
+        fun shouldEmitUnavailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withServerError()
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isFalse()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
+
+            verifier.verify()
         }
     }
 
@@ -105,19 +190,19 @@ class ConnectionCheckServiceTest {
 
         lateinit var mockRestServiceServer: MockRestServiceServer
         lateinit var service: GIcsConnectionCheckService
+        lateinit var sink: Sinks.Many<ConnectionCheckResult>
 
         @BeforeEach
-        fun setUp(
-            @Mock sink: Sinks.Many<ConnectionCheckResult>
-        ) {
+        fun setUp() {
             val restTemplate = RestTemplate()
-            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
 
             val gicsTargetProperties = GIcsConfigProperties(
                 "http://localhost/gics",
                 "username",
                 "password",
             )
+            this.sink = Sinks.many().multicast().onBackpressureBuffer()
+            this.mockRestServiceServer = MockRestServiceServer.createServer(restTemplate)
 
             this.service = GIcsConnectionCheckService(restTemplate, gicsTargetProperties, sink)
         }
@@ -136,6 +221,50 @@ class ConnectionCheckServiceTest {
             this.mockRestServiceServer.verify()
 
         }
+
+        @Test
+        fun shouldEmitAvailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withSuccess("OK", MediaType.APPLICATION_JSON),
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isTrue()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
+
+            verifier.verify()
+        }
+
+        @Test
+        fun shouldEmitUnavailable() {
+            this.mockRestServiceServer
+                .expect(method(HttpMethod.GET))
+                .andRespond(
+                    withServerError()
+                )
+
+            val verifier = StepVerifier.create(sink.asFlux())
+                .assertNext {
+                    assertThat(it.available).isFalse()
+                }
+                .expectComplete()
+                .verifyLater()
+
+            this.service.check()
+
+            this.sink.emitComplete(Sinks.EmitFailureHandler.FAIL_FAST)
+
+            verifier.verify()
+        }
     }
 
 }
\ No newline at end of file