NAV-24196: Ryddet opp i eksiterende kode og tester (#5067)

### 💰 Hva skal gjøres, og hvorfor?
Favro:
https://favro.com/organization/98c34fb974ce445eac854de0/1844bbac3b6605eacc8f5543?card=NAV-24196

Kom over eksiterende kode som kan ryddes opp i, tok det derfor ut i en
egen PR.

- Gjorde valideringsmetoder `private`.
- Innførte `@Nested inner class` i testene for bedre organisering.
- Innførte arrange-act-assert kommentarer i testene for bedre
organisering.
- Innførte flere asserts hvor det ga mening.

### 🔎️ Er det noe spesielt du ønsker tilbakemelding om?
Nei

### ✅ Checklist
_Har du husket alle punktene i listen?_
- [ ] Jeg har testet mine endringer i henhold til akseptansekriteriene
🕵️
- [ ] Jeg har config- eller sql-endringer. I så fall, husk manuell
deploy til miljø for å verifisere endringene.
- [ ] Jeg har skrevet tester. Hvis du ikke har skrevet tester, beskriv
hvorfor under 👇

_Jeg har ikke skrevet tester fordi:_
Ikke relevant.

### 💬 Ønsker du en muntlig gjennomgang?
- [ ] Ja
- [x] Nei

src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/StegService.kt

@@ -110,7 +110,9 @@ class StegService(
 
                 else ->
                     when (nyBehandling.behandlingType) {
-                        BehandlingType.FØRSTEGANGSBEHANDLING -> emptyList()
+                        BehandlingType.FØRSTEGANGSBEHANDLING,
+                        -> emptyList()
+
                         BehandlingType.REVURDERING,
                         BehandlingType.TEKNISK_ENDRING,
                         BehandlingType.MIGRERING_FRA_INFOTRYGD,
@@ -141,7 +143,7 @@ class StegService(
         }
     }
 
-    fun validerEndreMigreringsdato(nyBehandling: NyBehandling) {
+    private fun validerEndreMigreringsdato(nyBehandling: NyBehandling) {
         check(nyBehandling.behandlingÅrsak == BehandlingÅrsak.ENDRE_MIGRERINGSDATO)
 
         if (!satsendringService.erFagsakOppdatertMedSisteSatser(fagsakId = nyBehandling.fagsakId)) {
@@ -155,7 +157,7 @@ class StegService(
         }
     }
 
-    fun validerIverksettKAVedtak() {
+    private fun validerIverksettKAVedtak() {
         if (!unleashService.isEnabled(FeatureToggle.KAN_OPPRETTE_REVURDERING_MED_ÅRSAK_IVERKSETTE_KA_VEDTAK)) {
             throw FunksjonellFeil("Det er ikke mulig å opprette behandling med årsak Iverksette KA-vedtak")
         }

src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/steg/StegServiceTest.kt

@@ -1,12 +1,16 @@
 package no.nav.familie.ba.sak.kjerne.steg
 
 import io.mockk.every
+import io.mockk.just
 import io.mockk.mockk
+import io.mockk.runs
 import io.mockk.verify
 import no.nav.familie.ba.sak.common.FunksjonellFeil
 import no.nav.familie.ba.sak.config.FeatureToggle
 import no.nav.familie.ba.sak.config.featureToggle.UnleashNextMedContextService
 import no.nav.familie.ba.sak.datagenerator.lagBehandling
+import no.nav.familie.ba.sak.datagenerator.lagFagsak
+import no.nav.familie.ba.sak.datagenerator.randomAktør
 import no.nav.familie.ba.sak.datagenerator.randomFnr
 import no.nav.familie.ba.sak.kjerne.autovedtak.satsendring.SatsendringService
 import no.nav.familie.ba.sak.kjerne.autovedtak.satsendring.domene.Satskjøring
@@ -19,25 +23,28 @@ import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingKategori
 import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingStatus
 import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingType
 import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori
+import no.nav.familie.ba.sak.kjerne.behandling.domene.Behandlingsresultat
 import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingÅrsak
+import no.nav.familie.ba.sak.sikkerhet.SikkerhetContext
+import no.nav.familie.ba.sak.sikkerhet.TilgangService
 import no.nav.familie.ba.sak.task.OpprettTaskService
 import org.assertj.core.api.Assertions.assertThat
-import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
-import org.junit.jupiter.api.assertDoesNotThrow
 import org.junit.jupiter.api.assertThrows
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.YearMonth
 
-internal class StegServiceTest {
+class StegServiceTest {
     private val behandlingService: BehandlingService = mockk()
     private val behandlingHentOgPersisterService: BehandlingHentOgPersisterService = mockk()
     private val satsendringService: SatsendringService = mockk()
-    private val opprettTaskService: OpprettTaskService = mockk(relaxed = true)
-    private val satskjøringRepository: SatskjøringRepository = mockk(relaxed = true)
+    private val opprettTaskService: OpprettTaskService = mockk()
+    private val satskjøringRepository: SatskjøringRepository = mockk()
     private val unleashService: UnleashNextMedContextService = mockk()
+    private val tilgangService: TilgangService = mockk()
 
     private val stegService =
         StegService(
@@ -47,7 +54,7 @@ internal class StegServiceTest {
             behandlingHentOgPersisterService = behandlingHentOgPersisterService,
             beregningService = mockk(),
             søknadGrunnlagService = mockk(),
-            tilgangService = mockk(relaxed = true),
+            tilgangService = tilgangService,
             infotrygdFeedService = mockk(),
             satsendringService = satsendringService,
             personopplysningerService = mockk(),
@@ -59,44 +66,80 @@ internal class StegServiceTest {
 
     @BeforeEach
     fun setup() {
-        val behandling = lagBehandling()
-        every { behandlingService.opprettBehandling(any()) } returns behandling
-        every { behandlingService.leggTilStegPåBehandlingOgSettTidligereStegSomUtført(any(), any()) } returns behandling
-        every { behandlingHentOgPersisterService.hent(any()) } returns behandling
+        every { tilgangService.validerTilgangTilBehandling(any(), any()) } just runs
+        every { tilgangService.verifiserHarTilgangTilHandling(any(), any()) } just runs
     }
 
-    @Test
-    fun `skal IKKE feile validering av helmanuell migrering når fagsak har aktivt vedtak som er et opphør`() {
-        every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = any()) } returns
-            lagBehandling()
+    @Nested
+    inner class HåndterNyBehandlingTest {
+        @Test
+        fun `skal ikke feile validering av helmanuell migrering når fagsak har aktivt vedtak som er et opphør`() {
+            // Arrange
+            val foreldre = randomAktør()
+            val barn = randomAktør()
 
-        every { behandlingService.erLøpende(any()) } returns false
+            val forrigeBehandling = lagBehandling()
 
-        assertDoesNotThrow {
-            stegService.håndterNyBehandling(
+            val nyBehandling =
                 NyBehandling(
                     kategori = BehandlingKategori.NASJONAL,
                     underkategori = BehandlingUnderkategori.ORDINÆR,
                     behandlingType = BehandlingType.MIGRERING_FRA_INFOTRYGD,
                     behandlingÅrsak = BehandlingÅrsak.HELMANUELL_MIGRERING,
-                    søkersIdent = randomFnr(),
-                    barnasIdenter = listOf(randomFnr()),
+                    søkersIdent = foreldre.aktivFødselsnummer(),
+                    barnasIdenter = listOf(barn.aktivFødselsnummer()),
                     nyMigreringsdato = LocalDate.now().minusMonths(6),
                     fagsakId = 1L,
-                ),
-            )
-        }
-    }
+                )
 
-    @Test
-    fun `skal feile validering av helmanuell migrering når fagsak har aktivt vedtak med løpende utbetalinger`() {
-        every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = any()) } returns
-            lagBehandling()
+            val opprettetBehandling =
+                lagBehandling(
+                    fagsak =
+                        lagFagsak(
+                            id = nyBehandling.fagsakId,
+                            aktør = foreldre,
+                        ),
+                    behandlingKategori = nyBehandling.kategori!!,
+                    underkategori = nyBehandling.underkategori!!,
+                    behandlingType = nyBehandling.behandlingType,
+                    årsak = nyBehandling.behandlingÅrsak,
+                )
 
-        every { behandlingService.erLøpende(any()) } returns true
+            every { behandlingHentOgPersisterService.hent(opprettetBehandling.id) } returns opprettetBehandling
+            every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(nyBehandling.fagsakId) } returns forrigeBehandling
+            every { behandlingService.erLøpende(forrigeBehandling) } returns false
+            every { behandlingService.opprettBehandling(nyBehandling) } returns opprettetBehandling
+            every { behandlingService.leggTilStegPåBehandlingOgSettTidligereStegSomUtført(opprettetBehandling.id, any()) } returns opprettetBehandling
 
-        assertThrows<FunksjonellFeil> {
-            stegService.håndterNyBehandling(
+            // Act
+            val håndtertNyBehandling = stegService.håndterNyBehandling(nyBehandling)
+
+            // Assert
+            assertThat(håndtertNyBehandling.id).isNotNull()
+            assertThat(håndtertNyBehandling.fagsak.id).isEqualTo(1L)
+            assertThat(håndtertNyBehandling.behandlingStegTilstand).hasSize(1)
+            assertThat(håndtertNyBehandling.resultat).isEqualTo(Behandlingsresultat.IKKE_VURDERT)
+            assertThat(håndtertNyBehandling.type).isEqualTo(BehandlingType.MIGRERING_FRA_INFOTRYGD)
+            assertThat(håndtertNyBehandling.opprettetÅrsak).isEqualTo(BehandlingÅrsak.HELMANUELL_MIGRERING)
+            assertThat(håndtertNyBehandling.skalBehandlesAutomatisk).isFalse()
+            assertThat(håndtertNyBehandling.kategori).isEqualTo(nyBehandling.kategori)
+            assertThat(håndtertNyBehandling.underkategori).isEqualTo(nyBehandling.underkategori)
+            assertThat(håndtertNyBehandling.aktiv).isTrue()
+            assertThat(håndtertNyBehandling.status).isEqualTo(BehandlingStatus.UTREDES)
+            assertThat(håndtertNyBehandling.overstyrtEndringstidspunkt).isNull()
+            assertThat(håndtertNyBehandling.aktivertTidspunkt).isNotNull()
+            assertThat(håndtertNyBehandling.opprettetAv).isEqualTo(SikkerhetContext.SYSTEM_FORKORTELSE)
+            assertThat(håndtertNyBehandling.opprettetTidspunkt).isNotNull()
+            assertThat(håndtertNyBehandling.endretAv).isEqualTo(SikkerhetContext.SYSTEM_FORKORTELSE)
+            assertThat(håndtertNyBehandling.endretTidspunkt).isNotNull()
+            assertThat(håndtertNyBehandling.versjon).isEqualTo(0L)
+            assertThat(håndtertNyBehandling.steg).isEqualTo(StegType.REGISTRERE_PERSONGRUNNLAG)
+        }
+
+        @Test
+        fun `skal feile validering av helmanuell migrering når fagsak har aktivt vedtak med løpende utbetalinger`() {
+            // Arrange
+            val nyBehandling =
                 NyBehandling(
                     kategori = BehandlingKategori.NASJONAL,
                     underkategori = BehandlingUnderkategori.ORDINÆR,
@@ -106,84 +149,108 @@ internal class StegServiceTest {
                     barnasIdenter = listOf(randomFnr()),
                     nyMigreringsdato = LocalDate.now().minusMonths(6),
                     fagsakId = 1L,
-                ),
-            )
+                )
+
+            every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(nyBehandling.fagsakId) } returns lagBehandling()
+            every { behandlingService.erLøpende(any()) } returns true
+
+            // Act & assert
+            val exception = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
+            assertThat(exception.message).isEqualTo("Det finnes allerede en vedtatt behandling med løpende utbetalinger på fagsak 1.Behandling kan ikke opprettes med årsak Manuell migrering")
         }
-    }
 
-    @Test
-    fun `Skal feile og trigge satsendring dersom vi har en gammel sats på forrige iverksatte behandling på endre migreringsdato behandling`() {
-        every { satsendringService.erFagsakOppdatertMedSisteSatser(any()) } returns false
-        every { satskjøringRepository.findByFagsakIdAndSatsTidspunkt(any(), any()) } returns null
-
-        val nyBehandling =
-            NyBehandling(
-                kategori = BehandlingKategori.NASJONAL,
-                underkategori = BehandlingUnderkategori.ORDINÆR,
-                behandlingType = BehandlingType.REVURDERING,
-                behandlingÅrsak = BehandlingÅrsak.ENDRE_MIGRERINGSDATO,
-                søkersIdent = randomFnr(),
-                barnasIdenter = listOf(randomFnr()),
-                nyMigreringsdato = LocalDate.now().minusMonths(6),
-                fagsakId = 1L,
-            )
-
-        val feil = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
-        verify(exactly = 1) { opprettTaskService.opprettSatsendringTask(any(), any()) }
-        assertThat(feil.melding).isEqualTo("Fagsaken har ikke siste sats. Det har automatisk blitt opprettet en behandling for satsendring. Vent til den er ferdig behandlet før du endrer migreringsdato.")
-    }
+        @Test
+        fun `skal kaste feil dersom behandlingsårsak er IVERKSETTE_KA_VEDTAK og toggle ikke er skrudd på`() {
+            // Arrange
+            val nyBehandling =
+                NyBehandling(
+                    søkersIdent = randomFnr(),
+                    behandlingType = BehandlingType.REVURDERING,
+                    behandlingÅrsak = BehandlingÅrsak.IVERKSETTE_KA_VEDTAK,
+                    fagsakId = 1L,
+                )
+
+            every { unleashService.isEnabled(FeatureToggle.KAN_OPPRETTE_REVURDERING_MED_ÅRSAK_IVERKSETTE_KA_VEDTAK) } returns false
 
-    @Test
-    fun `Skal ikke trigge ny satsendring dersom vi har en gammel sats på forrige iverksatte behandling på endre migreringsdato behandling, og satsendring allerede er trigget`() {
-        every { satsendringService.erFagsakOppdatertMedSisteSatser(any()) } returns false
-        every { satskjøringRepository.findByFagsakIdAndSatsTidspunkt(any(), any()) } returns Satskjøring(fagsakId = 1, startTidspunkt = LocalDateTime.now(), satsTidspunkt = YearMonth.now())
-
-        val nyBehandling =
-            NyBehandling(
-                kategori = BehandlingKategori.NASJONAL,
-                underkategori = BehandlingUnderkategori.ORDINÆR,
-                behandlingType = BehandlingType.REVURDERING,
-                behandlingÅrsak = BehandlingÅrsak.ENDRE_MIGRERINGSDATO,
-                søkersIdent = randomFnr(),
-                barnasIdenter = listOf(randomFnr()),
-                nyMigreringsdato = LocalDate.now().minusMonths(6),
-                fagsakId = 1L,
-            )
-
-        val feil = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
-        verify(exactly = 0) { opprettTaskService.opprettSatsendringTask(any(), any()) }
-        assertThat(feil.melding).isEqualTo("Det kjøres satsendring på fagsaken. Vennligst prøv igjen senere")
+            // Act & assert
+            val exception = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
+            assertThat(exception.melding).isEqualTo("Det er ikke mulig å opprette behandling med årsak Iverksette KA-vedtak")
+        }
     }
 
-    @Test
-    fun `opprettBehandling - skal kaste feil dersom behandlingsårsak er IVERKSETTE_KA_VEDTAK og toggle ikke er skrudd på`() {
-        every { unleashService.isEnabled(FeatureToggle.KAN_OPPRETTE_REVURDERING_MED_ÅRSAK_IVERKSETTE_KA_VEDTAK) } returns false
-
-        val funksjonellFeil =
-            assertThrows<FunksjonellFeil> {
-                stegService.håndterNyBehandling(
-                    NyBehandling(
-                        søkersIdent = randomFnr(),
-                        behandlingType = BehandlingType.REVURDERING,
-                        behandlingÅrsak = BehandlingÅrsak.IVERKSETTE_KA_VEDTAK,
-                        fagsakId = 1,
-                    ),
+    @Nested
+    inner class OpprettSatsendringTaskTest {
+        @Test
+        fun `Skal feile og trigge satsendring dersom vi har en gammel sats på forrige iverksatte behandling på endre migreringsdato behandling`() {
+            // Arrange
+            val nyBehandling =
+                NyBehandling(
+                    kategori = BehandlingKategori.NASJONAL,
+                    underkategori = BehandlingUnderkategori.ORDINÆR,
+                    behandlingType = BehandlingType.REVURDERING,
+                    behandlingÅrsak = BehandlingÅrsak.ENDRE_MIGRERINGSDATO,
+                    søkersIdent = randomFnr(),
+                    barnasIdenter = listOf(randomFnr()),
+                    nyMigreringsdato = LocalDate.now().minusMonths(6),
+                    fagsakId = 1L,
                 )
-            }
 
-        assertThat(funksjonellFeil.melding).isEqualTo("Det er ikke mulig å opprette behandling med årsak Iverksette KA-vedtak")
+            every { satsendringService.erFagsakOppdatertMedSisteSatser(nyBehandling.fagsakId) } returns false
+            every { satskjøringRepository.findByFagsakIdAndSatsTidspunkt(nyBehandling.fagsakId, any()) } returns null
+            every { opprettTaskService.opprettSatsendringTask(nyBehandling.fagsakId, any()) } just runs
+
+            // Act & assert
+            val exception = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
+            assertThat(exception.melding).isEqualTo("Fagsaken har ikke siste sats. Det har automatisk blitt opprettet en behandling for satsendring. Vent til den er ferdig behandlet før du endrer migreringsdato.")
+            verify(exactly = 1) { opprettTaskService.opprettSatsendringTask(any(), any()) }
+        }
+
+        @Test
+        fun `Skal ikke trigge ny satsendring dersom vi har en gammel sats på forrige iverksatte behandling på endre migreringsdato behandling, og satsendring allerede er trigget`() {
+            // Arrange
+            val nyBehandling =
+                NyBehandling(
+                    kategori = BehandlingKategori.NASJONAL,
+                    underkategori = BehandlingUnderkategori.ORDINÆR,
+                    behandlingType = BehandlingType.REVURDERING,
+                    behandlingÅrsak = BehandlingÅrsak.ENDRE_MIGRERINGSDATO,
+                    søkersIdent = randomFnr(),
+                    barnasIdenter = listOf(randomFnr()),
+                    nyMigreringsdato = LocalDate.now().minusMonths(6),
+                    fagsakId = 1L,
+                )
+
+            every { satsendringService.erFagsakOppdatertMedSisteSatser(nyBehandling.fagsakId) } returns false
+            every { satskjøringRepository.findByFagsakIdAndSatsTidspunkt(nyBehandling.fagsakId, any()) } returns Satskjøring(fagsakId = 1, startTidspunkt = LocalDateTime.now(), satsTidspunkt = YearMonth.now())
+
+            // Act & assert
+            val exception = assertThrows<FunksjonellFeil> { stegService.håndterNyBehandling(nyBehandling) }
+            assertThat(exception.melding).isEqualTo("Det kjøres satsendring på fagsaken. Vennligst prøv igjen senere")
+            verify(exactly = 0) { opprettTaskService.opprettSatsendringTask(any(), any()) }
+        }
     }
 
-    @Test
-    fun `Skal feile dersom behandlingen er satt på vent`() {
-        val behandling = lagBehandling(status = BehandlingStatus.SATT_PÅ_VENT)
-        val grunnlag = RegistrerPersongrunnlagDTO("", emptyList())
-        assertThatThrownBy { stegService.håndterPersongrunnlag(behandling, grunnlag) }
-            .hasMessageContaining("er på vent")
+    @Nested
+    inner class HåndterPersongrunnlagTest {
+        @Test
+        fun `skal feile dersom behandlingen er satt på vent`() {
+            // Arange
+            val behandling = lagBehandling(status = BehandlingStatus.SATT_PÅ_VENT)
+            val grunnlag = RegistrerPersongrunnlagDTO("123", emptyList())
+
+            // Act & assert
+            val exception = assertThrows<FunksjonellFeil> { stegService.håndterPersongrunnlag(behandling, grunnlag) }
+            assertThat(exception.message).isEqualTo("System prøver å utføre steg REGISTRERE_PERSONGRUNNLAG på behandling ${behandling.id} som er på vent.")
+        }
     }
 
     private fun mockRegistrerPersongrunnlag() =
-        object : RegistrerPersongrunnlag(mockk(), mockk(), mockk(), mockk()) {
+        object : RegistrerPersongrunnlag(
+            behandlingHentOgPersisterService = mockk(),
+            vilkårsvurderingForNyBehandlingService = mockk(),
+            personopplysningGrunnlagForNyBehandlingService = mockk(),
+            eøsSkjemaerForNyBehandlingService = mockk(),
+        ) {
             override fun utførStegOgAngiNeste(
                 behandling: Behandling,
                 data: RegistrerPersongrunnlagDTO,