Fjern overflødig Pair, for lesbarhetens skyld

Author: havstein

src/main/kotlin/no/nav/helse/behovsakkumulator/Behovsakkumulator.kt

@@ -14,7 +14,7 @@ class Behovsakkumulator(rapidsConnection: RapidsConnection) : River.PacketListen
     private val log = LoggerFactory.getLogger(this::class.java)
     private val sikkerLog = LoggerFactory.getLogger("tjenestekall")
 
-    private val behovUtenLøsning = mutableMapOf<String, Pair<MessageContext, JsonMessage>>()
+    private val behovUtenLøsning = mutableMapOf<String, JsonMessage>()
 
     init {
         River(rapidsConnection).apply {
@@ -39,14 +39,14 @@ class Behovsakkumulator(rapidsConnection: RapidsConnection) : River.PacketListen
         loggBehov(sikkerLog, packet)
 
         val id = packet.behovId()
-        val resultat = behovUtenLøsning[id]?.let { context to it.second.kombinerLøsninger(packet) } ?: (context to packet)
-
-        if (resultat.second.erKomplett()) {
-            resultat.second["@final"] = true
-            resultat.second["@besvart"] = LocalDateTime.now().toString()
-            loggLøstBehov(log, resultat.second)
-            loggLøstBehov(sikkerLog, resultat.second)
-            resultat.first.publish(resultat.second.toJson())
+        val resultat = behovUtenLøsning[id]?.kombinerLøsninger(packet) ?: packet
+
+        if (resultat.erKomplett()) {
+            resultat["@final"] = true
+            resultat["@besvart"] = LocalDateTime.now().toString()
+            loggLøstBehov(log, resultat)
+            loggLøstBehov(sikkerLog, resultat)
+            context.publish(resultat.toJson())
             behovUtenLøsning.remove(id)
         } else {
             fjernGamleBehovUtenSvar(context)
@@ -57,27 +57,27 @@ class Behovsakkumulator(rapidsConnection: RapidsConnection) : River.PacketListen
     private fun fjernGamleBehovUtenSvar(context: MessageContext) {
         val grense = LocalDateTime.now().minusMinutes(30)
         behovUtenLøsning
-            .filterValues { (_, packet) -> packet["@opprettet"].asLocalDateTime().isBefore(grense) }
-            .forEach { (key, value) ->
-                val forventninger = value.second["@behov"].map(JsonNode::asText)
-                val løsninger = value.second["@løsning"].feltnavn()
+            .filterValues { packet -> packet["@opprettet"].asLocalDateTime().isBefore(grense) }
+            .forEach { (key, packet) ->
+                val forventninger = packet["@behov"].map(JsonNode::asText)
+                val løsninger = packet["@løsning"].feltnavn()
                 val mangler = forventninger.filter { it !in løsninger }
 
-                loggFjerneGammeltBehov(log, value.second, mangler)
-                loggFjerneGammeltBehov(sikkerLog, value.second, mangler)
+                loggFjerneGammeltBehov(log, packet, mangler)
+                loggFjerneGammeltBehov(sikkerLog, packet, mangler)
                 behovUtenLøsning.remove(key)
 
-                val behovId = value.second.behovId()
+                val behovId = packet.behovId()
                 context.publish(behovId, JsonMessage.newMessage(mapOf(
                     "@event_name" to "behov_uten_fullstendig_løsning",
                     "@id" to UUID.randomUUID(),
                     "@opprettet" to LocalDateTime.now(),
                     "behov_id" to behovId,
-                    "behov_opprettet" to value.second["@opprettet"].asLocalDateTime(),
+                    "behov_opprettet" to packet["@opprettet"].asLocalDateTime(),
                     "forventet" to forventninger,
                     "løsninger" to løsninger,
                     "mangler" to mangler,
-                    "ufullstendig_behov" to value.second.toJson()
+                    "ufullstendig_behov" to packet.toJson()
                 )).toJson().also {
                     sikkerLog.info("sender event=behov_uten_fullstendig_løsning:\n\t$it")
                 })

src/test/kotlin/no/nav/helse/behovsakkumulator/BehovsakkumulatorTest.kt

@@ -9,6 +9,7 @@ import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import no.nav.helse.rapids_rivers.MessageContext
 import no.nav.helse.rapids_rivers.RapidsConnection
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertNotEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
@@ -128,6 +129,43 @@ internal class BehovsakkumulatorTest {
         assertEquals(1, rapid.sentMessages.size)
     }
 
+    @Test
+    fun `publiserer endelig svar med samme key som siste melding`() {
+        val behov = objectMapper.readTree("""{"@id": "${UUID.randomUUID()}", "@behovId": "en_behovId", "@opprettet": "${LocalDateTime.now()}", "vedtaksperiodeId": "id", "@behov": ["AndreYtelser", "HeltAndreYtelser"]}""")
+        val løsning1 = behov.medLøsning("""{ "AndreYtelser": { "felt1": null, "felt2": {}} }""")
+        val løsning2 = behov.medLøsning("""{ "HeltAndreYtelser": { "felt1": null, "felt2": {}} }""")
+        rapid.sendTestMessage("behov_nøkkel", behov.toString())
+        rapid.sendTestMessage("behov_nøkkel", løsning1)
+        // I virkeligheten skjer det neppe at en løsning kommer på en annen key enn behovet, dette er bare for å vise
+        // hva aktuell oppførsel er
+        val usannsynligKey = "behov_nøkkel_sist"
+        rapid.sendTestMessage(usannsynligKey, løsning2)
+
+        assertEquals(1, rapid.sentMessages.size)
+        val (key, packet) = rapid.sentMessages.first()
+        assertEquals(usannsynligKey, key)
+        assertTrue(packet["@final"].asBoolean())
+    }
+
+    @Test
+    fun `publiserer behov_uten_fullstendig_løsning med en annen key enn mottatt melding`() {
+        val behovId_somIkkeBlirKomplett = "en_behovId"
+        val behov = objectMapper.readTree("""{"@id": "${UUID.randomUUID()}", "@behovId": "$behovId_somIkkeBlirKomplett", "@opprettet": "${LocalDateTime.now().minusMinutes(31)}", "vedtaksperiodeId": "id", "@behov": ["AndreYtelser", "NoenAndreYtelser", "HeltAndreYtelser"]}""")
+        val løsning1 = behov.medLøsning("""{ "AndreYtelser": { "felt1": null, "felt2": {}} }""")
+        val løsningBehov2 =
+            objectMapper.readTree("""{"@id": "${UUID.randomUUID()}", "@behovId": "en_annen_behovId", "@opprettet": "${LocalDateTime.now()}", "vedtaksperiodeId": "id2", "@behov": ["AndreYtelser", "NoenAndreYtelser"]}""")
+                .medLøsning("""{ "AndreYtelser": { "felt1": null, "felt2": {}} }""")
+        rapid.sendTestMessage("behov_nøkkel", behov.toString())
+        rapid.sendTestMessage("behov_nøkkel", løsning1)
+        rapid.sendTestMessage("behov_nøkkel", løsningBehov2)
+
+        assertEquals(1, rapid.sentMessages.size)
+        val (key, packet) = rapid.sentMessages.first()
+        assertNotEquals("behov_nøkkel", key)
+        assertEquals(behovId_somIkkeBlirKomplett, key)
+        assertEquals("behov_uten_fullstendig_løsning", packet["@event_name"].asText())
+    }
+
     private fun JsonNode.medLøsning(løsning: String) =
         (this.deepCopy() as ObjectNode).apply {
             put("@id", UUID.randomUUID().toString())