håndterer out of order-situasjon

foredler/src/main/kotlin/no/nav/helse/spekemat/foredler/Pølsefabrikk.kt

@@ -13,12 +13,28 @@ class Pølsefabrikk private constructor(
     }
 
     fun nyPølse(pølse: Pølse) {
-        // ny rad hvis pølsen finnes fra før
-        if (pakken.isEmpty() || pakken[0].skalLageNyRad(pølse))
-            return pakken.add(0, pakken.getOrNull(0)?.nyPølserad(pølse) ?: Pølserad(listOf(pølse), pølse.kilde))
+        if (skalLageNyrad(pølse)) return lagNyRad(pølse)
         pakken[0] = pakken[0].nyPølse(pølse)
     }
 
+    private fun skalLageNyrad(pølse: Pølse) =
+        pakken.isEmpty() || pakken[0].skalLageNyRad(pølse)
+
+    private fun lagNyRad(pølse: Pølse) {
+        if (pakken.isEmpty()) {
+            pakken.add(Pølserad(listOf(pølse), pølse.kilde))
+            return
+        }
+
+        val pølserad = pakken[0].nyPølserad(pølse)
+        // fjerner pølser med samme kilde fordi det må antyde en out of order-situasjon hvor vi:
+        // 1) først opprettes en ny pølse med kilde X, dvs. den legges bare til gjeldende rad. Den nye perioden trigger dog revurdering av senere perioder
+        // 2) så mottas generasjon_opprettet på etterfølgende perioder med kilde X, og det skal lages ny rad. Da må pølsen opprettet i steg 1) fjernes
+        //    fra raden som "pushes ned", og kun beholdes på siste/nyeste rad
+        pakken[0] = pakken[0].fjernPølserMedSammeKilde(pølse)
+        pakken.add(0, pølserad)
+    }
+
     fun pakke() = pakken.map { it.dto() }
 }
 
@@ -29,6 +45,11 @@ data class Pølserad(
     fun skalLageNyRad(other: Pølse) =
         pølser.any { pølse -> other.erNyPølseAv(pølse) && this.kildeTilRad != other.kilde }
 
+    fun fjernPølserMedSammeKilde(other: Pølse) =
+        this.copy(
+            pølser = pølser.filterNot { it.kilde == other.kilde }
+        )
+
     fun nyPølserad(pølse: Pølse): Pølserad {
         return this
             .nyPølse(pølse)

foredler/src/test/kotlin/no/nav/helse/spekemat/foredler/Database.kt

@@ -3,8 +3,8 @@ package no.nav.helse.spekemat.foredler
 import com.zaxxer.hikari.HikariConfig
 import com.zaxxer.hikari.HikariDataSource
 import org.flywaydb.core.Flyway
+import org.testcontainers.DockerClientFactory
 import org.testcontainers.containers.PostgreSQLContainer
-import javax.sql.DataSource
 
 object Database {
     private lateinit var flyway: Flyway
@@ -14,6 +14,16 @@ object Database {
             withCreateContainerCmdModifier { command -> command.withName("spekemat") }
             withReuse(true)
             withLabel("app-navn", "spekemat")
+            DockerClientFactory.lazyClient().apply {
+                this
+                    .listContainersCmd()
+                    .exec()
+                    .filter { it.labels["app-navn"] == "spekemat" }
+                    .forEach {
+                        killContainerCmd(it.id).exec()
+                        removeContainerCmd(it.id).withForce(true).exec()
+                    }
+            }
             start()
         }
     }

foredler/src/test/kotlin/no/nav/helse/spekemat/foredler/PølsefabrikkTest.kt

@@ -1,6 +1,6 @@
 package no.nav.helse.spekemat.foredler
 
-import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import java.time.LocalDate
@@ -22,7 +22,7 @@ class PølsefabrikkTest {
         fabrikk.nyPølse(p1)
 
         val result = fabrikk.pakke()
-        Assertions.assertEquals(1, result.size) // forventer én rad
+        assertEquals(1, result.size) // forventer én rad
         assertEquals(setOf(p1), result.single()) // rekkefølgen på rad 1
     }
 
@@ -35,7 +35,7 @@ class PølsefabrikkTest {
         fabrikk.nyPølse(p2)
 
         val result = fabrikk.pakke()
-        Assertions.assertEquals(1, result.size) // forventer én rad
+        assertEquals(1, result.size) // forventer én rad
         assertEquals(setOf(p2, p1), result.single()) // rekkefølgen på rad 1
     }
 
@@ -48,7 +48,7 @@ class PølsefabrikkTest {
         fabrikk.nyPølse(p1)
 
         val result = fabrikk.pakke()
-        Assertions.assertEquals(1, result.size) // forventer én rad
+        assertEquals(1, result.size) // forventer én rad
         assertEquals(setOf(p2, p1), result.single()) // rekkefølgen på rad 1
     }
 
@@ -67,8 +67,8 @@ class PølsefabrikkTest {
         fabrikk.nyPølse(p2Revurdering) // en ny pølse for p2 må bety at forrige pølse er avsluttet
 
         val result = fabrikk.pakke()
-        Assertions.assertEquals(2, result.size) // forventer to rader
-        Assertions.assertEquals(revurderingkilde, result[0].kildeTilRad)
+        assertEquals(2, result.size) // forventer to rader
+        assertEquals(revurderingkilde, result[0].kildeTilRad)
         assertEquals(setOf(p2Revurdering, p1), result[0]) // rekkefølgen på rad 1
         assertEquals(setOf(p2, p1), result[1]) // rekkefølgen på rad 2
     }
@@ -90,11 +90,37 @@ class PølsefabrikkTest {
         fabrikk.nyPølse(p1Revurdering) // en ny pølse for p2 må bety at forrige pølse er avsluttet
 
         val result = fabrikk.pakke()
-        Assertions.assertEquals(2, result.size) // forventer to rader
+        assertEquals(2, result.size) // forventer to rader
         assertEquals(setOf(p2Revurdering, p1Revurdering), result[0]) // rekkefølgen på rad 1
         assertEquals(setOf(p2, p1), result[1]) // rekkefølgen på rad 2 er uvesentlig:
     }
 
+    @Test
+    fun `out of order`() {
+        val v1 = UUID.randomUUID()
+        val v2 = UUID.randomUUID()
+        val v3 = UUID.randomUUID()
+        val oufOrderOrderkilde = UUID.randomUUID()
+
+        val p1 = 10.januar til 20.januar som v1
+        val p2 = 21.januar til 31.januar som v2
+        val p3 = 1.januar til 5.januar som v3 fordi oufOrderOrderkilde
+        val p2Revurdering = p2.fordi(oufOrderOrderkilde)
+        val p1Revurdering = p1.fordi(oufOrderOrderkilde)
+
+        fabrikk.nyPølse(p1)
+        fabrikk.nyPølse(p2)
+
+        fabrikk.nyPølse(p3)
+        fabrikk.nyPølse(p2Revurdering)
+        fabrikk.nyPølse(p1Revurdering)
+
+        val result = fabrikk.pakke()
+        assertEquals(2, result.size) // forventer to rader
+        assertEquals(setOf(p3, p2Revurdering, p1Revurdering), result[0])
+        assertEquals(setOf(p2, p1), result[1])
+    }
+
     private fun pølse(
         vedtaksperiodeId: UUID,
         kilde: UUID = UUID.randomUUID()
@@ -111,8 +137,8 @@ class PølsefabrikkTest {
         assertEquals(expected, actual.pølser)
     }
     private fun assertEquals(expected: Set<Pølse>, actual: List<PølseDto>) {
-        Assertions.assertEquals(expected.size, actual.size)
+        assertEquals(expected.size, actual.size)
         val ingenMatch = expected.map { it.dto() }.filterNot { it in actual }
-        Assertions.assertEquals(emptyList<PølseDto>(), ingenMatch) { "Det er pølser som ikke finnes i actual" }
+        assertEquals(emptyList<PølseDto>(), ingenMatch) { "Det er pølser som ikke finnes i actual" }
     }
 }