feat: support for asynchronous follow-up count calculation (#300)

This is required if async messaging is used. The request is already gone if response gets processed.

Workflow:

* Keep old followup_count
* Add expected_followup_count
* If: DNPM:DIP accepts the request - copy to to followup_count
* Else: keep old followup_count

This prevents from saving unaccepted follow-up counts.

2 files changed, 47 insertions, 5 deletions

diff --git a/src/test/kotlin/dev/dnpm/etl/processor/services/RequestProcessorTest.kt b/src/test/kotlin/dev/dnpm/etl/processor/services/RequestProcessorTest.kt
index 0fea80a..7e771df 100644
--- a/src/test/kotlin/dev/dnpm/etl/processor/services/RequestProcessorTest.kt
+++ b/src/test/kotlin/dev/dnpm/etl/processor/services/RequestProcessorTest.kt
@@ -1294,7 +1294,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.FOLLOWUP)
-            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(0)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -1415,7 +1416,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.FOLLOWUP)
-            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(0)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -1522,6 +1524,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.FOLLOWUP)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(0)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -1645,6 +1649,7 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.ADDITION)
             assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -1786,7 +1791,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.FOLLOWUP)
-            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(2)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(2)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -1910,6 +1916,7 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.ADDITION)
             assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -2004,7 +2011,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.INITIAL)
-            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(1)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(0)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(1)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
@@ -2104,7 +2112,8 @@ class RequestProcessorTest {
             assertThat(requestCaptor.firstValue).isNotNull
             assertThat(requestCaptor.firstValue.status).isEqualTo(RequestStatus.UNKNOWN)
             assertThat(requestCaptor.firstValue.submissionType).isEqualTo(SubmissionType.ADDITION)
-            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(0)
+            assertThat(requestCaptor.firstValue.followupCount).isEqualTo(-1)
+            assertThat(requestCaptor.firstValue.expectedFollowupCount).isEqualTo(0)
 
             val eventCaptor = argumentCaptor<ResponseEvent>()
             verify(applicationEventPublisher, times(1)).publishEvent(eventCaptor.capture())
diff --git a/src/test/kotlin/dev/dnpm/etl/processor/services/ResponseProcessorTest.kt b/src/test/kotlin/dev/dnpm/etl/processor/services/ResponseProcessorTest.kt
index 441f3a9..c7a0af7 100644
--- a/src/test/kotlin/dev/dnpm/etl/processor/services/ResponseProcessorTest.kt
+++ b/src/test/kotlin/dev/dnpm/etl/processor/services/ResponseProcessorTest.kt
@@ -32,6 +32,7 @@ import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 import org.mockito.Mock
 import org.mockito.junit.jupiter.MockitoExtension
@@ -115,6 +116,27 @@ class ResponseProcessorTest {
     assertThat(captor.firstValue.status).isEqualTo(requestStatus)
   }
 
+  @ParameterizedTest
+  @MethodSource("requestFollowUpCount")
+  fun shoulUpdateFollowUpCountFromExpectedFollowUpCountOnSuccess(requestStatus: RequestStatus, followUpCount: Int, expectedFollowUpCount: Int) {
+    doAnswer {
+        testRequest.followupCount = followUpCount
+        testRequest.expectedFollowupCount = expectedFollowUpCount
+        Optional.of(testRequest)
+    }.whenever(requestService).findByUuid(anyValueClass())
+
+    val event =
+        ResponseEvent(RequestId("TestID1234"), Instant.parse("2023-09-09T00:00:00Z"), requestStatus)
+
+    this.responseProcessor.handleResponseEvent(event)
+
+    val captor = argumentCaptor<Request>()
+    verify(requestService, times(1)).save(captor.capture())
+    assertThat(captor.firstValue).isNotNull
+    assertThat(captor.firstValue.status).isEqualTo(requestStatus)
+    assertThat(captor.firstValue.followupCount).isEqualTo(expectedFollowUpCount)
+  }
+
   companion object {
 
     @JvmStatic
@@ -126,5 +148,16 @@ class ResponseProcessorTest {
           RequestStatus.DUPLICATION,
       )
     }
+
+    @JvmStatic
+    fun requestFollowUpCount(): Set<Arguments> {
+      return setOf(
+          Arguments.of(RequestStatus.SUCCESS, 1, 2),
+          Arguments.of(RequestStatus.WARNING, 1, 2),
+          Arguments.of(RequestStatus.ERROR, 1, 1),
+          Arguments.of(RequestStatus.DUPLICATION, 1, 1),
+          Arguments.of(RequestStatus.NO_CONSENT, 1, 1),
+      )
+    }
   }
 }