Verifiser sak->tilbakekrevinger for IT-testen

test-common/src/main/kotlin/json/AssertJsonEquals.kt

@@ -13,14 +13,14 @@ fun String.shouldBeSimilarJsonTo(expectedJson: String, vararg ignoredPaths: Stri
     }
     if (customizations.isEmpty()) {
         JSONAssert.assertEquals(
-            this,
             expectedJson,
+            this,
             JSONCompareMode.STRICT,
         )
     } else {
         JSONAssert.assertEquals(
-            this,
             expectedJson,
+            this,
             CustomComparator(
                 JSONCompareMode.STRICT,
                 *customizations.toTypedArray(),

tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/KanOppdatereKravgrunnlag.kt

@@ -33,6 +33,6 @@ sealed interface KanOppdatereKravgrunnlag : KanEndres {
             utførtAv = command.oppdatertAv,
             kravgrunnlagPåSakHendelseId = nyttKravgrunnlag.hendelseId,
         )
-        return hendelse to hendelse.applyToState(this, kravgrunnlag)
+        return hendelse to hendelse.applyToState(this, nyttKravgrunnlag)
     }
 }

web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AvbrytTilbakekrevingsbehandling.kt

@@ -11,16 +11,22 @@ import kotlinx.coroutines.runBlocking
 import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle
 import no.nav.su.se.bakover.test.json.shouldBeSimilarJsonTo
 import no.nav.su.se.bakover.web.SharedRegressionTestData
+import no.nav.su.se.bakover.web.komponenttest.AppComponents
+import no.nav.su.se.bakover.web.sak.hent.hentSak
+import org.json.JSONObject
 
-fun avbrytTilbakekrevingsbehandling(
+internal fun AppComponents.avbrytTilbakekrevingsbehandling(
     sakId: String,
     tilbakekrevingsbehandlingId: String,
     expectedHttpStatusCode: HttpStatusCode = HttpStatusCode.Created,
     client: HttpClient,
     verifiserRespons: Boolean = true,
+    utførSideeffekter: Boolean = true,
     saksversjon: Long,
-): Pair<String, Long> {
-    val expectedVersjon: Long = saksversjon + 1
+): AvbrytTilbakekrevingRespons {
+    val appComponents = this
+    val sakFørKallJson = hentSak(sakId, client)
+    val tidligereUtførteSideeffekter = hentUtførteSideeffekter(sakId)
     return runBlocking {
         SharedRegressionTestData.defaultRequest(
             HttpMethod.Post,
@@ -33,19 +39,60 @@ fun avbrytTilbakekrevingsbehandling(
             withClue("Kunne ikke avbryte tilbakekrevingsbehandling: ${this.bodyAsText()}") {
                 status shouldBe expectedHttpStatusCode
             }
-        }.bodyAsText().also {
-            if (verifiserRespons) {
-                verifiserAvbrytTilbakekrevingRespons(
-                    actual = it,
-                    tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
+        }.bodyAsText().let { responseJson ->
+            if (utførSideeffekter) {
+                // Vi kjører konsumentene 2 ganger, for å se at vi ikke oppretter duplikate oppgaver.
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
+                    sakId = sakId,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
+                    antallLukketOppgaver = 1,
+                )
+                // Vi sletter statusen på jobben, men ikke selve oppgavehendelsen for å verifisere at vi ikke oppretter duplikate oppgaver i disse tilfellene.
+                appComponents.slettLukketOppgaveKonsumentJobb()
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
                     sakId = sakId,
-                    expectedVersjon = expectedVersjon,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
+                    antallLukketOppgaver = 1,
                 )
             }
-        } to expectedVersjon
+            val sakEtterKallJson = hentSak(sakId, client)
+            val saksversjonEtter = JSONObject(sakEtterKallJson).getLong("versjon")
+            if (verifiserRespons) {
+                if (utførSideeffekter) {
+                    // oppgavehendelse
+                    saksversjonEtter shouldBe saksversjon + 2
+                } else {
+                    saksversjonEtter shouldBe saksversjon + 1
+                }
+                sakEtterKallJson.shouldBeSimilarJsonTo(sakFørKallJson, "versjon", "tilbakekrevinger")
+                listOf(
+                    responseJson,
+                    JSONObject(sakEtterKallJson).getJSONArray("tilbakekrevinger").getJSONObject(0).toString(),
+                ).forEach {
+                    verifiserAvbrytTilbakekrevingRespons(
+                        actual = it,
+                        tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
+                        sakId = sakId,
+                        expectedVersjon = saksversjon + 1,
+                    )
+                }
+            }
+            AvbrytTilbakekrevingRespons(
+                responseJson = responseJson,
+                saksversjon = saksversjonEtter,
+            )
+        }
     }
 }
 
+internal data class AvbrytTilbakekrevingRespons(
+    val responseJson: String,
+    val saksversjon: Long,
+)
+
 fun verifiserAvbrytTilbakekrevingRespons(
     actual: String,
     tilbakekrevingsbehandlingId: String,
@@ -94,8 +141,11 @@ fun verifiserAvbrytTilbakekrevingRespons(
   "versjon": $expectedVersjon,
   "attesteringer": [],
   "erKravgrunnlagUtdatert": false,
-  "avsluttetTidspunkt": "2021-02-01T01:04:43.456789Z",
+  "avsluttetTidspunkt": "2021-02-01T01:04:46.456789Z",
   "notat": null,
 }"""
     actual.shouldBeSimilarJsonTo(expected, "kravgrunnlag.hendelseId", "opprettet", "kravgrunnlag.kontrollfelt")
+    JSONObject(actual).has("opprettet") shouldBe true
+    JSONObject(actual).getJSONObject("kravgrunnlag").has("hendelseId") shouldBe true
+    JSONObject(actual).getJSONObject("kravgrunnlag").has("kontrollfelt") shouldBe true
 }

web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/ForhåndsvarsleTilbakekrevingsbehandling.kt

@@ -27,6 +27,7 @@ internal fun AppComponents.forhåndsvarsleTilbakekrevingsbehandling(
     fritekst: String = "Regresjonstest: Fritekst til forhåndsvarsel under tilbakekrevingsbehandling.",
 ): ForhåndsvarsletTilbakekrevingRespons {
     val sakFørKallJson = hentSak(sakId, client)
+    val tidligereUtførteSideeffekter = hentUtførteSideeffekter(sakId)
     val appComponents = this
     return runBlocking {
         SharedRegressionTestData.defaultRequest(
@@ -38,14 +39,14 @@ internal fun AppComponents.forhåndsvarsleTilbakekrevingsbehandling(
             withClue("Kunne ikke forhåndsvarsle tilbakekrevingsbehandling: ${this.bodyAsText()}") {
                 status shouldBe expectedHttpStatusCode
             }
-        }.bodyAsText().let {
+        }.bodyAsText().let { responseJson ->
             if (utførSideeffekter) {
                 // Vi kjører konsumentene 2 ganger, for å se at vi ikke oppretter duplikate oppgaver.
-                appComponents.kjøreAlleTilbakekrevingskonsumenter()
-                appComponents.kjøreAlleTilbakekrevingskonsumenter()
-                appComponents.kjøreAlleVerifiseringer(
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
                     sakId = sakId,
-                    antallOpprettetOppgaver = 1,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
                     antallOppdatertOppgaveHendelser = 1,
                     antallGenererteForhåndsvarsler = 1,
                     antallJournalførteDokumenter = 1,
@@ -55,10 +56,10 @@ internal fun AppComponents.forhåndsvarsleTilbakekrevingsbehandling(
                 appComponents.slettOppdatertOppgaveKonsumentJobb()
                 appComponents.slettGenererDokumentForForhåndsvarselKonsumentJobb()
                 // Ikke denne testen sitt ansvar og verifisere journalføring og distribusjon av dokumenter, så vi sletter ikke de.
-                appComponents.kjøreAlleTilbakekrevingskonsumenter()
-                appComponents.kjøreAlleVerifiseringer(
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
                     sakId = sakId,
-                    antallOpprettetOppgaver = 1,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
                     antallOppdatertOppgaveHendelser = 1,
                     antallGenererteForhåndsvarsler = 1,
                     antallJournalførteDokumenter = 1,
@@ -75,25 +76,22 @@ internal fun AppComponents.forhåndsvarsleTilbakekrevingsbehandling(
                     saksversjonEtter shouldBe saksversjon + 1 // kun hendelsen
                 }
                 sakEtterKallJson.shouldBeSimilarJsonTo(sakFørKallJson, "versjon", "tilbakekrevinger")
-                verifiserForhåndsvarsletTilbakekrevingsbehandlingRespons(
-                    actual = it,
-                    sakId = sakId,
-                    tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
-                    expectedVersjon = saksversjon + 1,
-                )
-                val tilbakekreving =
-                    JSONObject(sakEtterKallJson).getJSONArray("tilbakekrevinger").getJSONObject(0).toString()
-                verifiserForhåndsvarsletTilbakekrevingsbehandlingRespons(
-                    actual = tilbakekreving,
-                    sakId = sakId,
-                    tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
-                    expectedVersjon = saksversjon + 1,
-                )
+                listOf(
+                    responseJson,
+                    JSONObject(sakEtterKallJson).getJSONArray("tilbakekrevinger").getJSONObject(0).toString(),
+                ).forEach {
+                    verifiserForhåndsvarsletTilbakekrevingsbehandlingRespons(
+                        actual = it,
+                        sakId = sakId,
+                        tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
+                        expectedVersjon = saksversjon + 1,
+                    )
+                }
             }
             ForhåndsvarsletTilbakekrevingRespons(
-                forhåndsvarselInfo = hentForhåndsvarselDokumenter(it),
+                forhåndsvarselInfo = hentForhåndsvarselDokumenter(responseJson),
                 saksversjon = saksversjonEtter,
-                responseJson = it,
+                responseJson = responseJson,
             )
         }
     }

web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/ForhåndsvisForhåndsvarselTilbakekrevingsbehandling.kt

@@ -21,6 +21,7 @@ fun forhåndsvisForhåndsvarselTilbakekreving(
     saksversjon: Long,
     fritekst: String? = "Regresjonstest: Fritekst til forhåndsvarsel under tilbakekrevingsbehandling.",
 ): String {
+    // Dette kallet muterer ikke.
     return runBlocking {
         SharedRegressionTestData.defaultRequest(
             HttpMethod.Post,

web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/ForhåndsvisVedtaksbrevTilbakekrevingsbehandling.kt

@@ -18,6 +18,7 @@ fun forhåndsvisVedtaksbrevTilbakekrevingsbehandling(
     client: HttpClient,
     verifiserRespons: Boolean = true,
 ): String {
+    // Dette kallet muterer ikke.
     return runBlocking {
         SharedRegressionTestData.defaultRequest(
             HttpMethod.Get,

web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/IverksettTilbakekrevingsbehandling.kt

@@ -17,7 +17,7 @@ import no.nav.su.se.bakover.web.sak.hent.hentSak
 import org.json.JSONArray
 import org.json.JSONObject
 
-fun AppComponents.iverksettTilbakekrevingsbehandling(
+internal fun AppComponents.iverksettTilbakekrevingsbehandling(
     sakId: String,
     tilbakekrevingsbehandlingId: String,
     expectedHttpStatusCode: HttpStatusCode = HttpStatusCode.Created,
@@ -30,9 +30,10 @@ fun AppComponents.iverksettTilbakekrevingsbehandling(
     verifiserVurderinger: String,
     verifiserFritekst: String,
     tidligereAttesteringer: String? = null,
-): Pair<String, Long> {
-    val sakFørKallJson = hentSak(sakId, client)
+): IverksettTilbakekrevingsbehandlingRespons {
     val appComponents = this
+    val sakFørKallJson = hentSak(sakId, client)
+    val tidligereUtførteSideeffekter = hentUtførteSideeffekter(sakId)
     return runBlocking {
         SharedRegressionTestData.defaultRequest(
             HttpMethod.Post,
@@ -44,67 +45,84 @@ fun AppComponents.iverksettTilbakekrevingsbehandling(
             withClue("Kunne ikke iverksette tilbakekrevingsbehandling: ${this.bodyAsText()}") {
                 status shouldBe expectedHttpStatusCode
             }
-        }.bodyAsText().let {
+        }.bodyAsText().let { responseJson ->
             if (utførSideeffekter) {
-                appComponents.kjøreAlleTilbakekrevingskonsumenter()
-                appComponents.kjøreAlleVerifiseringer(
+                // Vi kjører konsumentene 2 ganger, for å se at vi ikke oppretter duplikate oppgaver.
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
                     sakId = sakId,
-                    antallOpprettetOppgaver = 1,
-                    antallOppdatertOppgaveHendelser = 4,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
                     antallLukketOppgaver = 1,
-                    antallGenererteForhåndsvarsler = 1,
                     antallGenererteVedtaksbrev = 1,
-                    antallJournalførteDokumenter = 2,
-                    antallDistribuertDokumenter = 2,
+                    antallJournalførteDokumenter = 1,
+                    antallDistribuertDokumenter = 1,
+                )
+                // Vi sletter statusen på jobben, men ikke selve oppgavehendelsen for å verifisere at vi ikke oppretter duplikate oppgaver i disse tilfellene.
+                appComponents.slettLukketOppgaveKonsumentJobb()
+                appComponents.slettGenererDokumentForForhåndsvarselKonsumentJobb()
+                // Ikke denne testen sitt ansvar og verifisere journalføring og distribusjon av dokumenter, så vi sletter ikke de.
+                appComponents.kjørAlleTilbakekrevingskonsumenter()
+                appComponents.kjørAlleVerifiseringer(
+                    sakId = sakId,
+                    tidligereUtførteSideeffekter = tidligereUtførteSideeffekter,
+                    antallLukketOppgaver = 1,
+                    antallGenererteVedtaksbrev = 1,
+                    antallJournalførteDokumenter = 1,
+                    antallDistribuertDokumenter = 1,
                 )
             }
             val sakEtterKallJson = hentSak(sakId, client)
-            sakEtterKallJson.shouldBeSimilarJsonTo(sakFørKallJson, "versjon", "tilbakekrevinger", "vedtak")
-            verifiserTilbakekrevingsVedtak(tilbakekrevingsbehandlingId, JSONObject(sakEtterKallJson).getJSONArray("vedtak"))
             val saksversjonEtter = JSONObject(sakEtterKallJson).getLong("versjon")
-
             if (verifiserRespons) {
                 if (utførSideeffekter) {
-                    saksversjonEtter shouldBe saksversjon + 5 // hendelse + lukket oppgave + generering av brev + journalført + distribuert
+                    // hendelse + lukket oppgave + generering av brev + journalført + distribuert
+                    saksversjonEtter shouldBe saksversjon + 5
                 } else {
-                    saksversjonEtter shouldBe saksversjon + 1 // kun hendelsen
+                    // kun hendelsen
+                    saksversjonEtter shouldBe saksversjon + 1
                 }
-                verifiserIverksattTilbakekrevingsbehandlingRespons(
-                    actual = it,
-                    sakId = sakId,
-                    tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
-                    expectedVersjon = saksversjon + 1,
-                    forhåndsvarselDokumenter = verifiserForhåndsvarselDokumenter,
-                    vurderinger = verifiserVurderinger,
-                    fritekst = verifiserFritekst,
-                    tidligereAttesteringer = tidligereAttesteringer,
-                )
-
-                val tilbakekreving =
-                    JSONObject(sakEtterKallJson).getJSONArray("tilbakekrevinger").getJSONObject(0).toString()
-                verifiserIverksattTilbakekrevingsbehandlingRespons(
-                    actual = tilbakekreving,
-                    sakId = sakId,
-                    tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
-                    expectedVersjon = saksversjon + 1,
-                    forhåndsvarselDokumenter = verifiserForhåndsvarselDokumenter,
-                    vurderinger = verifiserVurderinger,
-                    fritekst = verifiserFritekst,
-                    tidligereAttesteringer = tidligereAttesteringer,
+                sakEtterKallJson.shouldBeSimilarJsonTo(sakFørKallJson, "versjon", "tilbakekrevinger", "vedtak")
+                verifiserTilbakekrevingsVedtak(
+                    tilbakekrevingsbehandlingId,
+                    JSONObject(sakEtterKallJson).getJSONArray("vedtak"),
                 )
+                listOf(
+                    responseJson,
+                    JSONObject(sakEtterKallJson).getJSONArray("tilbakekrevinger").getJSONObject(0).toString(),
+                ).forEach {
+                    verifiserIverksattTilbakekrevingsbehandlingRespons(
+                        actual = it,
+                        sakId = sakId,
+                        tilbakekrevingsbehandlingId = tilbakekrevingsbehandlingId,
+                        forhåndsvarselDokumenter = verifiserForhåndsvarselDokumenter,
+                        vurderinger = verifiserVurderinger,
+                        fritekst = verifiserFritekst,
+                        expectedVersjon = saksversjon + 1,
+                        tidligereAttesteringer = tidligereAttesteringer,
+                    )
+                }
             }
-            it to saksversjonEtter
+            IverksettTilbakekrevingsbehandlingRespons(
+                saksversjon = saksversjonEtter,
+                responseJson = responseJson,
+            )
         }
     }
 }
 
+internal data class IverksettTilbakekrevingsbehandlingRespons(
+    val responseJson: String,
+    val saksversjon: Long,
+)
+
 private fun verifiserTilbakekrevingsVedtak(tilbakekrevingsbehandlingId: String, vedtakJson: JSONArray) {
     vedtakJson.length() shouldBe 3
     val tilbakekrevingsvedtak = vedtakJson.getJSONObject(2)
     val expected = """
                 {
                     "id":"ignore-me",
-                    "opprettet":"2021-02-01T01:04:11.456789Z",
+                    "opprettet":"ignore-me",
                     "beregning":null,
                     "simulering":null,
                     "attestant":"AttestantLokal",
@@ -116,7 +134,9 @@ private fun verifiserTilbakekrevingsVedtak(tilbakekrevingsbehandlingId: String,
                     "dokumenttilstand":"SENDT"
                 }
     """.trimIndent()
-    tilbakekrevingsvedtak.toString().shouldBeSimilarJsonTo(expected, "id")
+    tilbakekrevingsvedtak.toString().shouldBeSimilarJsonTo(expected, "id", "opprettet")
+    tilbakekrevingsvedtak.has("id") shouldBe true
+    tilbakekrevingsvedtak.has("opprettet") shouldBe true
 }
 
 fun verifiserIverksattTilbakekrevingsbehandlingRespons(
@@ -183,6 +203,11 @@ fun verifiserIverksattTilbakekrevingsbehandlingRespons(
   "notat": "notatet"
 }"""
     actual.shouldBeSimilarJsonTo(expected, "kravgrunnlag.hendelseId", "opprettet", "attesteringer[*].opprettet")
+    JSONObject(actual).has("opprettet") shouldBe true
+    JSONObject(actual).getJSONObject("kravgrunnlag").has("hendelseId") shouldBe true
+    JSONObject(actual).getJSONArray("attesteringer").all {
+        (it as JSONObject).has("opprettet")
+    } shouldBe true
 }
 
 fun String.removeFirstAndLastCharacter(): String {