From 4cfc25954ef18ef35a82b101be9977926b06cd41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christian=20B=C3=BClow=20Skovborg?= Date: Tue, 5 Nov 2024 12:06:40 +0100 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Bruker=20ikke=20lenger=20l?= =?UTF-8?q?ambda=20for=20oppretting=20av=20ny=20oppgave?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Instruerer i stedet OppgaveService om å lage oppgave og lagre denne --- .../no/nav/helse/spesialist/test/Test.kt | 2 + .../no/nav/helse/modell/oppgave/Oppgave.kt | 15 +- .../nav/helse/modell/oppgave/OppgaveTest.kt | 12 +- .../helse/mediator/oppgave/OppgaveService.kt | 13 +- .../kommando/OpprettSaksbehandleroppgave.kt | 56 ++-- .../nav/helse/mediator/OppgaveServiceTest.kt | 154 +++++------ .../mediator/oppgave/OppgavelagrerTest.kt | 2 +- .../mediator/oppgave/OppgavemelderTest.kt | 2 +- .../OpprettSaksbehandleroppgaveTest.kt | 245 ++++-------------- .../OppdaterOppgavestatusCommandTest.kt | 2 +- 10 files changed, 178 insertions(+), 325 deletions(-) diff --git a/spesialist-felles/src/testFixtures/kotlin/no/nav/helse/spesialist/test/Test.kt b/spesialist-felles/src/testFixtures/kotlin/no/nav/helse/spesialist/test/Test.kt index 9459682d2..8d21977ab 100644 --- a/spesialist-felles/src/testFixtures/kotlin/no/nav/helse/spesialist/test/Test.kt +++ b/spesialist-felles/src/testFixtures/kotlin/no/nav/helse/spesialist/test/Test.kt @@ -45,6 +45,8 @@ private val organisasjonsnavnDel2 = listOf("AVDELINGEN", "SENTERET", "FORUM", "K fun lagOrganisasjonsnavn() = organisasjonsnavnDel1.random() + organisasjonsnavnDel2.random() fun lagSaksbehandlerident() = ('A'..'Z').random() + "${nextInt(from = 100_000, until = 999_999)}" +fun lagSaksbehandlernavn() = "${lagFornavn()} ${lagEtternavn()}" +fun lagEpostadresseFraFulltNavn(navn: String) = navn.split(" ").joinToString(".").lowercase() + "@nav.no" fun fødselsdato(): LocalDate { val end = LocalDate.now().minusYears(18) diff --git a/spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/Oppgave.kt b/spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/Oppgave.kt index bafaa1af5..d52b36ff5 100644 --- a/spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/Oppgave.kt +++ b/spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/Oppgave.kt @@ -333,12 +333,19 @@ class Oppgave private constructor( utbetalingId: UUID, hendelseId: UUID, kanAvvises: Boolean, - egenskaper: List, + egenskaper: Set, totrinnsvurdering: Totrinnsvurdering? = null, ): Oppgave { - return Oppgave(id, AvventerSaksbehandler, vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, totrinnsvurdering).also { - it.egenskaper.addAll(egenskaper) - } + return Oppgave( + id = id, + tilstand = AvventerSaksbehandler, + vedtaksperiodeId = vedtaksperiodeId, + utbetalingId = utbetalingId, + hendelseId = hendelseId, + kanAvvises = kanAvvises, + totrinnsvurdering = totrinnsvurdering, + egenskaper = egenskaper.toMutableSet(), + ) } fun Oppgave.toDto() = diff --git a/spesialist-modell/src/test/kotlin/no/nav/helse/modell/oppgave/OppgaveTest.kt b/spesialist-modell/src/test/kotlin/no/nav/helse/modell/oppgave/OppgaveTest.kt index e1654dde6..c2da683a8 100644 --- a/spesialist-modell/src/test/kotlin/no/nav/helse/modell/oppgave/OppgaveTest.kt +++ b/spesialist-modell/src/test/kotlin/no/nav/helse/modell/oppgave/OppgaveTest.kt @@ -604,16 +604,16 @@ internal class OppgaveTest { UTBETALING_ID, UUID.randomUUID(), true, - listOf(OPPGAVETYPE), + setOf(OPPGAVETYPE), ) val oppgave1 = - Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, listOf(SØKNAD)) + Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD)) val oppgave2 = - Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, listOf(SØKNAD)) + Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD)) val oppgave3 = - Oppgave.nyOppgave(OPPGAVE_ID, UUID.randomUUID(), UTBETALING_ID, UUID.randomUUID(), true, listOf(SØKNAD)) + Oppgave.nyOppgave(OPPGAVE_ID, UUID.randomUUID(), UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD)) val oppgave4 = - Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, listOf(STIKKPRØVE)) + Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(STIKKPRØVE)) assertEquals(oppgave1, oppgave2) assertEquals(oppgave1.hashCode(), oppgave2.hashCode()) assertNotEquals(oppgave1, oppgave3) @@ -643,7 +643,7 @@ internal class OppgaveTest { UTBETALING_ID, UUID.randomUUID(), true, - egenskaper.toList(), + egenskaper.toSet(), totrinnsvurdering, ) } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveService.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveService.kt index 40d7ab5e8..eb3c4d742 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveService.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveService.kt @@ -29,6 +29,7 @@ import no.nav.helse.mediator.oppgave.OppgaveMapper.tilOppgaverTilBehandling import no.nav.helse.modell.Modellfeil import no.nav.helse.modell.oppgave.Egenskap import no.nav.helse.modell.oppgave.Oppgave +import no.nav.helse.modell.oppgave.Oppgave.Companion.nyOppgave import no.nav.helse.modell.oppgave.Oppgave.Companion.toDto import no.nav.helse.modell.saksbehandler.Saksbehandler import no.nav.helse.modell.saksbehandler.Tilgangskontroll @@ -89,15 +90,21 @@ internal class OppgaveService( internal fun nyOppgave( fødselsnummer: String, contextId: UUID, - opprettOppgaveBlock: (reservertId: Long) -> Oppgave, + vedtaksperiodeId: UUID, + utbetalingId: UUID, + hendelseId: UUID, + kanAvvises: Boolean, + egenskaper: Set, ) { + logg.info("Oppretter saksbehandleroppgave") + sikkerlogg.info("Oppretter saksbehandleroppgave for {}", kv("fødselsnummer", fødselsnummer)) val nesteId = oppgaveDao.reserverNesteId() - val oppgave = opprettOppgaveBlock(nesteId) val oppgavemelder = Oppgavemelder(fødselsnummer, rapidsConnection) + val oppgave = nyOppgave(nesteId, vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, egenskaper) oppgave.register(oppgavemelder) + oppgavemelder.oppgaveOpprettet(oppgave) tildelVedReservasjon(fødselsnummer, oppgave) Oppgavelagrer(tildelingRepository).lagre(this, oppgave.toDto(), contextId) - oppgavemelder.oppgaveOpprettet(oppgave) } fun oppgave( diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgave.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgave.kt index d05e8f054..97a6a0d43 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgave.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgave.kt @@ -35,7 +35,6 @@ import no.nav.helse.modell.oppgave.Egenskap.UTBETALING_TIL_ARBEIDSGIVER import no.nav.helse.modell.oppgave.Egenskap.UTBETALING_TIL_SYKMELDT import no.nav.helse.modell.oppgave.Egenskap.UTLAND import no.nav.helse.modell.oppgave.Egenskap.VERGEMÅL -import no.nav.helse.modell.oppgave.Oppgave import no.nav.helse.modell.person.HentEnhetløsning import no.nav.helse.modell.sykefraværstilfelle.Sykefraværstilfelle import no.nav.helse.modell.utbetaling.Utbetaling @@ -44,7 +43,6 @@ import no.nav.helse.modell.vedtaksperiode.GodkjenningsbehovData import no.nav.helse.modell.vedtaksperiode.Inntektskilde import no.nav.helse.modell.vedtaksperiode.Periodetype import no.nav.helse.spesialist.api.person.Adressebeskyttelse -import org.slf4j.LoggerFactory import java.util.UUID internal class OpprettSaksbehandleroppgave( @@ -61,22 +59,17 @@ internal class OpprettSaksbehandleroppgave( private val vedtakDao: VedtakDao, private val påVentRepository: PåVentRepository, ) : Command { - private companion object { - private val logg = LoggerFactory.getLogger(OpprettSaksbehandleroppgave::class.java) - private val sikkerLogg = LoggerFactory.getLogger("tjenestekall") - } - override fun execute(context: CommandContext): Boolean { val fødselsnummer = behovData.fødselsnummer val vedtaksperiodeId = behovData.vedtaksperiodeId val hendelseId = behovData.id - val utbetalingId = utbetaling.utbetalingId + val utbetalingId = behovData.utbetalingId val periodetype = behovData.periodetype val inntektskilde = behovData.inntektskilde val kanAvvises = behovData.kanAvvises val egenskaper = - emptyList() + emptySet() .vurderEgenAnsatt(fødselsnummer) .vurderAdressebeskyttelse(fødselsnummer) .vurderOppgavetype(utbetalingtype) @@ -95,23 +88,16 @@ internal class OpprettSaksbehandleroppgave( .vurderMedlemskap(vedtaksperiodeId) .vurderHaster(vedtaksperiodeId) - oppgaveService.nyOppgave(fødselsnummer, context.id()) { reservertId -> - val oppgave = Oppgave.nyOppgave(reservertId, vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, egenskaper) - - logg.info("Saksbehandleroppgave opprettet, avventer lagring: $oppgave") - sikkerLogg.info("Saksbehandleroppgave opprettet, avventer lagring: $oppgave") - oppgave - } - + oppgaveService.nyOppgave(fødselsnummer, context.id(), vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, egenskaper) return true } - private fun List.vurderEgenAnsatt(fødselsnummer: String): List { + private fun Set.vurderEgenAnsatt(fødselsnummer: String): Set { if (egenAnsattRepository.erEgenAnsatt(fødselsnummer) == true) return this + EGEN_ANSATT return this } - private fun List.vurderAdressebeskyttelse(fødselsnummer: String): List { + private fun Set.vurderAdressebeskyttelse(fødselsnummer: String): Set { val adressebeskyttelse = personRepository.finnAdressebeskyttelse(fødselsnummer) ?: return this return when (adressebeskyttelse) { Adressebeskyttelse.StrengtFortrolig, @@ -122,37 +108,37 @@ internal class OpprettSaksbehandleroppgave( } } - private fun List.vurderOppgavetype(utbetalingtype: Utbetalingtype): List { + private fun Set.vurderOppgavetype(utbetalingtype: Utbetalingtype): Set { if (utbetalingtype == Utbetalingtype.REVURDERING) return this + REVURDERING return this + SØKNAD } - private fun List.vurderStikkprøve( + private fun Set.vurderStikkprøve( vedtaksperiodeId: UUID, hendelseId: UUID, - ): List { + ): Set { if (automatisering.erStikkprøve(vedtaksperiodeId, hendelseId)) return this + STIKKPRØVE return this } - private fun List.vurderVurderingsmomenter(vedtaksperiodeId: UUID): List { + private fun Set.vurderVurderingsmomenter(vedtaksperiodeId: UUID): Set { if (!this.contains(REVURDERING) && risikovurderingRepository.kreverSupersaksbehandler(vedtaksperiodeId)) { return this + RISK_QA } return this } - private fun List.vurderVergemål(fødselsnummer: String): List { + private fun Set.vurderVergemål(fødselsnummer: String): Set { if (vergemålRepository.harVergemål(fødselsnummer) == true) return this + VERGEMÅL return this } - private fun List.vurderEnhetUtland(fødselsnummer: String): List { + private fun Set.vurderEnhetUtland(fødselsnummer: String): Set { if (HentEnhetløsning.erEnhetUtland(personRepository.finnEnhetId(fødselsnummer))) return this + UTLAND return this } - private fun List.vurderMottaker(): List { + private fun Set.vurderMottaker(): Set { return when { utbetaling.delvisRefusjon() -> this + DELVIS_REFUSJON utbetaling.kunUtbetalingTilSykmeldt() -> this + UTBETALING_TIL_SYKMELDT @@ -162,14 +148,14 @@ internal class OpprettSaksbehandleroppgave( } } - private fun List.vurderInntektskilde(inntektskilde: Inntektskilde): List { + private fun Set.vurderInntektskilde(inntektskilde: Inntektskilde): Set { return when (inntektskilde) { Inntektskilde.EN_ARBEIDSGIVER -> this + EN_ARBEIDSGIVER Inntektskilde.FLERE_ARBEIDSGIVERE -> this + FLERE_ARBEIDSGIVERE } } - private fun List.vurderPeriodetype(periodetype: Periodetype): List { + private fun Set.vurderPeriodetype(periodetype: Periodetype): Set { return when (periodetype) { Periodetype.FØRSTEGANGSBEHANDLING -> this + FORSTEGANGSBEHANDLING Periodetype.FORLENGELSE -> this + FORLENGELSE @@ -178,37 +164,37 @@ internal class OpprettSaksbehandleroppgave( } } - private fun List.vurderSpesialsak(vedtaksperiodeId: UUID): List { + private fun Set.vurderSpesialsak(vedtaksperiodeId: UUID): Set { if (vedtakDao.erSpesialsak(vedtaksperiodeId)) return this + SPESIALSAK return this } - private fun List.vurderPåVent(vedtaksperiodeId: UUID): List { + private fun Set.vurderPåVent(vedtaksperiodeId: UUID): Set { if (påVentRepository.erPåVent(vedtaksperiodeId)) return this + PÅ_VENT return this } - private fun List.vurderSkjønnsfastsettelse(vedtaksperiodeId: UUID): List { + private fun Set.vurderSkjønnsfastsettelse(vedtaksperiodeId: UUID): Set { if (sykefraværstilfelle.kreverSkjønnsfastsettelse(vedtaksperiodeId)) return this + SKJØNNSFASTSETTELSE return this } - private fun List.vurderTilbakedatert(vedtaksperiodeId: UUID): List { + private fun Set.vurderTilbakedatert(vedtaksperiodeId: UUID): Set { if (sykefraværstilfelle.erTilbakedatert(vedtaksperiodeId)) return this + TILBAKEDATERT return this } - private fun List.vurderKunÅpenGosysOppgave(vedtaksperiodeId: UUID): List { + private fun Set.vurderKunÅpenGosysOppgave(vedtaksperiodeId: UUID): Set { if (sykefraværstilfelle.harKunÅpenGosysOppgave(vedtaksperiodeId)) return this + GOSYS return this } - private fun List.vurderMedlemskap(vedtaksperiodeId: UUID): List { + private fun Set.vurderMedlemskap(vedtaksperiodeId: UUID): Set { if (sykefraværstilfelle.harMedlemskapsvarsel(vedtaksperiodeId)) return this + MEDLEMSKAP return this } - private fun List.vurderHaster(vedtaksperiodeId: UUID): List { + private fun Set.vurderHaster(vedtaksperiodeId: UUID): Set { if (sykefraværstilfelle.haster(vedtaksperiodeId) && utbetaling.harEndringIUtbetalingTilSykmeldt()) return this + HASTER return this } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/OppgaveServiceTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/OppgaveServiceTest.kt index 57024845c..2de1e8d23 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/OppgaveServiceTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/OppgaveServiceTest.kt @@ -28,10 +28,6 @@ import no.nav.helse.modell.kommando.TestMelding import no.nav.helse.modell.oppgave.Egenskap import no.nav.helse.modell.oppgave.Egenskap.STIKKPRØVE import no.nav.helse.modell.oppgave.Egenskap.SØKNAD -import no.nav.helse.modell.oppgave.Oppgave -import no.nav.helse.modell.oppgave.OppgaveInspector.Companion.oppgaveinspektør -import no.nav.helse.modell.saksbehandler.Saksbehandler -import no.nav.helse.modell.saksbehandler.Saksbehandler.Companion.toDto import no.nav.helse.rapids_rivers.testsupport.TestRapid import no.nav.helse.spesialist.api.abonnement.OpptegnelseType import no.nav.helse.spesialist.api.graphql.schema.AntallArbeidsforhold @@ -44,6 +40,10 @@ import no.nav.helse.spesialist.api.graphql.schema.Oppgavetype import no.nav.helse.spesialist.api.graphql.schema.Periodetype import no.nav.helse.spesialist.api.oppgave.Oppgavestatus import no.nav.helse.spesialist.api.saksbehandler.SaksbehandlerFraApi +import no.nav.helse.spesialist.test.lagEpostadresseFraFulltNavn +import no.nav.helse.spesialist.test.lagFødselsnummer +import no.nav.helse.spesialist.test.lagSaksbehandlerident +import no.nav.helse.spesialist.test.lagSaksbehandlernavn import no.nav.helse.testEnv import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue @@ -59,29 +59,27 @@ import kotlin.Int.Companion.MAX_VALUE import kotlin.random.Random.Default.nextLong internal class OppgaveServiceTest { - private companion object { - private const val FNR = "12345678911" - private val VEDTAKSPERIODE_ID = UUID.randomUUID() - private val UTBETALING_ID = UUID.randomUUID() - private val UTBETALING_ID_2 = UUID.randomUUID() - private val VEDTAKSPERIODE_ID_2 = UUID.randomUUID() - private val HENDELSE_ID = UUID.randomUUID() - private val COMMAND_CONTEXT_ID = UUID.randomUUID() - private val TESTHENDELSE = TestMelding(HENDELSE_ID, VEDTAKSPERIODE_ID, FNR) - private val OPPGAVE_ID = nextLong() - private const val SAKSBEHANDLERIDENT = "Z999999" - private val SAKSBEHANDLEROID = UUID.randomUUID() - private const val SAKSBEHANDLEREPOST = "saksbehandler@nav.no" - private const val SAKSBEHANDLERNAVN = "Hen Saksbehandler" - private val EGENSKAP_SØKNAD = EgenskapForDatabase.SØKNAD - private val EGENSKAPER = - setOf( - EgenskapForDatabase.SØKNAD, - EgenskapForDatabase.UTBETALING_TIL_SYKMELDT, - EgenskapForDatabase.EN_ARBEIDSGIVER, - EgenskapForDatabase.FORSTEGANGSBEHANDLING, - ) - } + private val FNR = lagFødselsnummer() + private val VEDTAKSPERIODE_ID = UUID.randomUUID() + private val UTBETALING_ID = UUID.randomUUID() + private val UTBETALING_ID_2 = UUID.randomUUID() + private val VEDTAKSPERIODE_ID_2 = UUID.randomUUID() + private val HENDELSE_ID = UUID.randomUUID() + private val COMMAND_CONTEXT_ID = UUID.randomUUID() + private val TESTHENDELSE = TestMelding(HENDELSE_ID, VEDTAKSPERIODE_ID, FNR) + private val OPPGAVE_ID = nextLong() + private val SAKSBEHANDLERIDENT = lagSaksbehandlerident() + private val SAKSBEHANDLEROID = UUID.randomUUID() + private val SAKSBEHANDLERNAVN = lagSaksbehandlernavn() + private val SAKSBEHANDLEREPOST = lagEpostadresseFraFulltNavn(SAKSBEHANDLERNAVN) + private val EGENSKAP_SØKNAD = EgenskapForDatabase.SØKNAD + private val EGENSKAPER = + setOf( + EgenskapForDatabase.SØKNAD, + EgenskapForDatabase.UTBETALING_TIL_SYKMELDT, + EgenskapForDatabase.EN_ARBEIDSGIVER, + EgenskapForDatabase.FORSTEGANGSBEHANDLING, + ) private val oppgaveDao = mockk(relaxed = true) private val tildelingRepository = mockk(relaxed = true) @@ -109,14 +107,13 @@ internal class OppgaveServiceTest { private fun saksbehandlerFraApi(tilganger: List = emptyList()) = SaksbehandlerFraApi(SAKSBEHANDLEROID, SAKSBEHANDLEREPOST, SAKSBEHANDLERNAVN, SAKSBEHANDLERIDENT, tilganger) - private val saksbehandler = - Saksbehandler(SAKSBEHANDLEREPOST, SAKSBEHANDLEROID, SAKSBEHANDLERNAVN, SAKSBEHANDLERIDENT, TilgangskontrollForTestHarIkkeTilgang) - - private fun søknadsoppgave(id: Long): Oppgave = - Oppgave.nyOppgave(id, VEDTAKSPERIODE_ID, UTBETALING_ID, HENDELSE_ID, true, listOf(SØKNAD)) + private fun lagSøknadsoppgave(fødselsnummer: String, contextId: UUID) { + mediator.nyOppgave(fødselsnummer, contextId, VEDTAKSPERIODE_ID, UTBETALING_ID, HENDELSE_ID, true, setOf(SØKNAD)) + } - private fun stikkprøveoppgave(id: Long): Oppgave = - Oppgave.nyOppgave(id, VEDTAKSPERIODE_ID_2, UTBETALING_ID_2, UUID.randomUUID(), true, listOf(STIKKPRØVE)) + private fun lagStikkprøveoppgave(fødselsnummer: String, contextId: UUID) { + mediator.nyOppgave(fødselsnummer, contextId, VEDTAKSPERIODE_ID_2, UTBETALING_ID_2, HENDELSE_ID, true, setOf(STIKKPRØVE)) + } @BeforeEach fun setup() { @@ -126,13 +123,12 @@ internal class OppgaveServiceTest { @Test fun `lagrer oppgaver`() { + val fødselsnummer = lagFødselsnummer() every { oppgaveDao.reserverNesteId() } returns 0L every { oppgaveDao.finnHendelseId(any()) } returns HENDELSE_ID - every { oppgaveDao.finnFødselsnummer(any()) } returns TESTHENDELSE.fødselsnummer() - every { reservasjonRepository.hentReservasjonFor(FNR) } returns null - mediator.nyOppgave(TESTHENDELSE.fødselsnummer(), COMMAND_CONTEXT_ID) { - søknadsoppgave(it) - } + every { oppgaveDao.finnFødselsnummer(any()) } returns fødselsnummer + every { reservasjonRepository.hentReservasjonFor(fødselsnummer) } returns null + lagSøknadsoppgave(fødselsnummer, COMMAND_CONTEXT_ID) verify(exactly = 1) { oppgaveDao.opprettOppgave( 0L, @@ -145,52 +141,41 @@ internal class OppgaveServiceTest { } assertEquals(1, testRapid.inspektør.size) assertOppgaveevent(0, "oppgave_opprettet") - assertAntallOpptegnelser(1) + assertAntallOpptegnelser(1, fødselsnummer) } @Test fun `lagrer oppgave og tildeler til saksbehandler som har reservert personen`() { every { oppgaveDao.reserverNesteId() } returns 0L - every { reservasjonRepository.hentReservasjonFor(TESTHENDELSE.fødselsnummer()) } returns Reservasjon(saksbehandlerFraDatabase) - every { oppgaveDao.finnFødselsnummer(any()) } returns TESTHENDELSE.fødselsnummer() - lateinit var oppgave: Oppgave - mediator.nyOppgave(TESTHENDELSE.fødselsnummer(), COMMAND_CONTEXT_ID) { - søknadsoppgave(it).also { søknadsoppgave -> oppgave = søknadsoppgave } - } - - oppgaveinspektør(oppgave) { - assertEquals(saksbehandler.toDto(), tildeltTil) - } - verify(exactly = 1) { tildelingRepository.tildel(any(), SAKSBEHANDLEROID) } - assertAntallOpptegnelser(1) + val fødselsnummer = lagFødselsnummer() + every { reservasjonRepository.hentReservasjonFor(fødselsnummer) } returns Reservasjon(saksbehandlerFraDatabase) + every { oppgaveDao.finnFødselsnummer(0L) } returns fødselsnummer + lagSøknadsoppgave(fødselsnummer, COMMAND_CONTEXT_ID) + verify(exactly = 1) { tildelingRepository.tildel(0L, SAKSBEHANDLEROID) } + assertAntallOpptegnelser(1, fødselsnummer) } @Test fun `tildeler ikke reservert personen når oppgave er stikkprøve`() { - every { oppgaveDao.reserverNesteId() } returns 0L - every { reservasjonRepository.hentReservasjonFor(TESTHENDELSE.fødselsnummer()) } returns Reservasjon(saksbehandlerFraDatabase) - every { oppgaveDao.finnFødselsnummer(any()) } returns TESTHENDELSE.fødselsnummer() - mediator.nyOppgave(TESTHENDELSE.fødselsnummer(), COMMAND_CONTEXT_ID) { - stikkprøveoppgave(it) - } + val fødselsnummer = lagFødselsnummer() + val oppgaveId = 0L + every { oppgaveDao.reserverNesteId() } returns oppgaveId + every { reservasjonRepository.hentReservasjonFor(fødselsnummer) } returns Reservasjon(saksbehandlerFraDatabase) + every { oppgaveDao.finnFødselsnummer(oppgaveId) } returns fødselsnummer + lagStikkprøveoppgave(fødselsnummer, COMMAND_CONTEXT_ID) verify(exactly = 0) { tildelingRepository.tildel(any(), any()) } - assertAntallOpptegnelser(1) + assertAntallOpptegnelser(1, fødselsnummer) } @Test fun `kaller bare hentGrupper når personen er reservert`() { - every { reservasjonRepository.hentReservasjonFor(TESTHENDELSE.fødselsnummer()) } returns null - every { oppgaveDao.reserverNesteId() } returns 0L - every { oppgaveDao.finnFødselsnummer(any()) } returns TESTHENDELSE.fødselsnummer() - lateinit var oppgave: Oppgave - mediator.nyOppgave(TESTHENDELSE.fødselsnummer(), COMMAND_CONTEXT_ID) { - stikkprøveoppgave(it).also { stikkprøveoppgave -> oppgave = stikkprøveoppgave } - } - - oppgaveinspektør(oppgave) { - assertEquals(null, tildeltTil) - } - assertAntallOpptegnelser(1) + val fødselsnummer = lagFødselsnummer() + val oppgaveId = 0L + every { reservasjonRepository.hentReservasjonFor(fødselsnummer) } returns null + every { oppgaveDao.reserverNesteId() } returns oppgaveId + every { oppgaveDao.finnFødselsnummer(oppgaveId) } returns fødselsnummer + lagStikkprøveoppgave(fødselsnummer, COMMAND_CONTEXT_ID) + assertAntallOpptegnelser(1, fødselsnummer) } @Test @@ -206,25 +191,26 @@ internal class OppgaveServiceTest { assertOppgaveevent(1, "oppgave_oppdatert", Oppgavestatus.Ferdigstilt) { assertEquals(OPPGAVE_ID, it.path("oppgaveId").longValue()) } - assertOpptegnelseIkkeOpprettet() + assertOpptegnelseIkkeOpprettet(TESTHENDELSE.fødselsnummer()) } @Test fun `lagrer ikke dobbelt`() { - every { oppgaveDao.reserverNesteId() } returns 0L - every { oppgaveDao.opprettOppgave(any(), any(), listOf(EGENSKAP_SØKNAD), any(), any(), any()) } returns 0L - every { oppgaveDao.finnFødselsnummer(any()) } returns TESTHENDELSE.fødselsnummer() - every { reservasjonRepository.hentReservasjonFor(FNR) } returns null + val fødselsnummer = lagFødselsnummer() + val oppgaveId = 0L + every { oppgaveDao.reserverNesteId() } returns oppgaveId + every { oppgaveDao.opprettOppgave(any(), any(), listOf(EGENSKAP_SØKNAD), any(), any(), any()) } returns oppgaveId + every { oppgaveDao.finnFødselsnummer(oppgaveId) } returns fødselsnummer + every { reservasjonRepository.hentReservasjonFor(fødselsnummer) } returns null + + lagSøknadsoppgave(fødselsnummer, COMMAND_CONTEXT_ID) - mediator.nyOppgave(TESTHENDELSE.fødselsnummer(), COMMAND_CONTEXT_ID) { - søknadsoppgave(it) - } assertEquals(1, testRapid.inspektør.size) - assertAntallOpptegnelser(1) + assertAntallOpptegnelser(1, fødselsnummer) testRapid.reset() clearMocks(opptegnelseRepository) assertEquals(0, testRapid.inspektør.size) - assertOpptegnelseIkkeOpprettet() + assertOpptegnelseIkkeOpprettet(fødselsnummer) } @Test @@ -500,16 +486,16 @@ internal class OppgaveServiceTest { assertEquals(egenskap.antallArbeidsforhold(), oppgave.antallArbeidsforhold) } - private fun assertAntallOpptegnelser(antallOpptegnelser: Int) = + private fun assertAntallOpptegnelser(antallOpptegnelser: Int, fødselsnummer: String) = verify(exactly = antallOpptegnelser) { opptegnelseRepository.opprettOpptegnelse( - eq(TESTHENDELSE.fødselsnummer()), + eq(fødselsnummer), any(), eq(OpptegnelseType.NY_SAKSBEHANDLEROPPGAVE), ) } - private fun assertOpptegnelseIkkeOpprettet() = assertAntallOpptegnelser(0) + private fun assertOpptegnelseIkkeOpprettet(fødselsnummer: String) = assertAntallOpptegnelser(0, fødselsnummer) private fun assertOppgaveevent( indeks: Int, diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavelagrerTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavelagrerTest.kt index 29739863f..2e831cfac 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavelagrerTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavelagrerTest.kt @@ -293,7 +293,7 @@ class OppgavelagrerTest : DatabaseIntegrationTest() { vedtaksperiodeId = VEDTAKSPERIODE_ID, utbetalingId = UTBETALING_ID, hendelseId = HENDELSE_ID, - egenskaper = listOf(OPPGAVETYPE), + egenskaper = setOf(OPPGAVETYPE), totrinnsvurdering = if (medTotrinnsvurdering) nyTotrinnsvurdering() else null, kanAvvises = true, ) diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavemelderTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavemelderTest.kt index 041db9020..a88addbc4 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavemelderTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/oppgave/OppgavemelderTest.kt @@ -83,7 +83,7 @@ class OppgavemelderTest { vedtaksperiodeId = VEDTAKSPERIODE_ID, utbetalingId = UTBETALING_ID, hendelseId = HENDELSE_ID, - egenskaper = listOf(SØKNAD), + egenskaper = setOf(SØKNAD), totrinnsvurdering = totrinnsvurdering, kanAvvises = true, ) diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgaveTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgaveTest.kt index 35f73ddf8..202a0f18e 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgaveTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgaveTest.kt @@ -3,7 +3,6 @@ package no.nav.helse.modell.kommando import io.mockk.clearMocks import io.mockk.every import io.mockk.mockk -import io.mockk.slot import io.mockk.verify import no.nav.helse.db.EgenAnsattRepository import no.nav.helse.db.PersonRepository @@ -16,19 +15,25 @@ import no.nav.helse.mediator.oppgave.OppgaveService import no.nav.helse.modell.automatisering.Automatisering import no.nav.helse.modell.oppgave.Egenskap import no.nav.helse.modell.oppgave.Egenskap.DELVIS_REFUSJON +import no.nav.helse.modell.oppgave.Egenskap.EGEN_ANSATT import no.nav.helse.modell.oppgave.Egenskap.EN_ARBEIDSGIVER +import no.nav.helse.modell.oppgave.Egenskap.FLERE_ARBEIDSGIVERE import no.nav.helse.modell.oppgave.Egenskap.FORSTEGANGSBEHANDLING import no.nav.helse.modell.oppgave.Egenskap.FORTROLIG_ADRESSE +import no.nav.helse.modell.oppgave.Egenskap.HASTER import no.nav.helse.modell.oppgave.Egenskap.INGEN_UTBETALING +import no.nav.helse.modell.oppgave.Egenskap.PÅ_VENT import no.nav.helse.modell.oppgave.Egenskap.REVURDERING import no.nav.helse.modell.oppgave.Egenskap.RISK_QA +import no.nav.helse.modell.oppgave.Egenskap.SKJØNNSFASTSETTELSE +import no.nav.helse.modell.oppgave.Egenskap.SPESIALSAK import no.nav.helse.modell.oppgave.Egenskap.STIKKPRØVE import no.nav.helse.modell.oppgave.Egenskap.STRENGT_FORTROLIG_ADRESSE import no.nav.helse.modell.oppgave.Egenskap.SØKNAD +import no.nav.helse.modell.oppgave.Egenskap.TILBAKEDATERT +import no.nav.helse.modell.oppgave.Egenskap.UTBETALING_TIL_ARBEIDSGIVER import no.nav.helse.modell.oppgave.Egenskap.UTBETALING_TIL_SYKMELDT -import no.nav.helse.modell.oppgave.EgenskapDto -import no.nav.helse.modell.oppgave.Oppgave -import no.nav.helse.modell.oppgave.OppgaveInspector.Companion.oppgaveinspektør +import no.nav.helse.modell.oppgave.Egenskap.UTLAND import no.nav.helse.modell.sykefraværstilfelle.Sykefraværstilfelle import no.nav.helse.modell.utbetaling.Utbetaling import no.nav.helse.modell.utbetaling.Utbetalingtype @@ -43,20 +48,18 @@ import no.nav.helse.spesialist.api.person.Adressebeskyttelse import no.nav.helse.spesialist.test.lagAktørId import no.nav.helse.spesialist.test.lagFødselsnummer import no.nav.helse.spesialist.test.lagOrganisasjonsnummer -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertFalse import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test -import org.junit.jupiter.api.parallel.Execution -import org.junit.jupiter.api.parallel.ExecutionMode import java.util.UUID -@Execution(ExecutionMode.SAME_THREAD) internal class OpprettSaksbehandleroppgaveTest { + private val FNR = lagFødselsnummer() private val VEDTAKSPERIODE_ID = UUID.randomUUID() private val UTBETALING_ID = UUID.randomUUID() - private val FNR = lagFødselsnummer() + private val HENDELSE_ID = UUID.randomUUID() + private val contextId = UUID.randomUUID() + private val context = CommandContext(contextId) private val oppgaveService = mockk(relaxed = true) private val automatisering = mockk(relaxed = true) @@ -67,334 +70,196 @@ internal class OpprettSaksbehandleroppgaveTest { private val sykefraværstilfelle = mockk(relaxed = true) private val vedtakDao = mockk(relaxed = true) private val påVentRepository = mockk(relaxed = true) - private lateinit var context: CommandContext - private lateinit var contextId: UUID - private lateinit var utbetalingstype: Utbetalingtype + private val command get() = opprettSaksbehandlerOppgaveCommand() private val utbetaling = mockk(relaxed = true) @BeforeEach fun beforeEach() { - contextId = UUID.randomUUID() - context = CommandContext(contextId) - utbetalingstype = Utbetalingtype.UTBETALING every { utbetaling.ingenUtbetaling() } returns true - } - - @BeforeEach - fun afterEach() { - contextId = UUID.randomUUID() - context = CommandContext(contextId) - utbetalingstype = Utbetalingtype.UTBETALING clearMocks(oppgaveService) } @Test fun `oppretter oppgave`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter stikkprøve`() { every { automatisering.erStikkprøve(VEDTAKSPERIODE_ID, any()) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, STIKKPRØVE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, STIKKPRØVE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter risk QA`() { every { risikovurderingRepository.kreverSupersaksbehandler(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, RISK_QA, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, RISK_QA, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter revurdering`() { - utbetalingstype = Utbetalingtype.REVURDERING - val slot = slot<((Long) -> Oppgave)>() - assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(REVURDERING, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertTrue(opprettSaksbehandlerOppgaveCommand(utbetalingtype = Utbetalingtype.REVURDERING).execute(context)) + assertForventedeEgenskaper(REVURDERING, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egen oppgavetype for fortrolig adresse`() { every { personRepository.finnAdressebeskyttelse(FNR) } returns Adressebeskyttelse.Fortrolig - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egen oppgavetype for strengt fortrolig adresse`() { every { personRepository.finnAdressebeskyttelse(FNR) } returns Adressebeskyttelse.StrengtFortrolig - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, STRENGT_FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, STRENGT_FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egen oppgavetype for strengt fortrolig adresse utland`() { every { personRepository.finnAdressebeskyttelse(FNR) } returns Adressebeskyttelse.StrengtFortroligUtland - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, STRENGT_FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, STRENGT_FORTROLIG_ADRESSE, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egen oppgavetype for utbetaling til sykmeldt`() { every { utbetaling.kunUtbetalingTilSykmeldt() } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, UTBETALING_TIL_SYKMELDT, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, UTBETALING_TIL_SYKMELDT, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egen oppgavetype for delvis refusjon`() { every { utbetaling.delvisRefusjon() } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, DELVIS_REFUSJON, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(SØKNAD, DELVIS_REFUSJON, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egenskap utbetaling til arbeidsgiver`() { every { utbetaling.kunUtbetalingTilArbeidsgiver() } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.UTBETALING_TIL_ARBEIDSGIVER)) - } + assertForventedeEgenskaper(SØKNAD, UTBETALING_TIL_ARBEIDSGIVER, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egenskap ingen utbetaling`() { every { utbetaling.ingenUtbetaling() } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.INGEN_UTBETALING)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `oppretter ikke oppgave med egenskap haster dersom det er utbetaling til arbeidsgiver`() { every { utbetaling.kunUtbetalingTilArbeidsgiver() } returns true every { sykefraværstilfelle.haster(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } + assertForventedeEgenskaper(SØKNAD, UTBETALING_TIL_ARBEIDSGIVER, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) + } - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertFalse(egenskaper.contains(EgenskapDto.HASTER)) - } + @Test + fun `oppretter oppgave med egenskap haster dersom det er endring i utbetaling til sykmeldte`() { + every { utbetaling.harEndringIUtbetalingTilSykmeldt() } returns true + every { sykefraværstilfelle.haster(VEDTAKSPERIODE_ID) } returns true + assertTrue(command.execute(context)) + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, HASTER) } @Test fun `oppretter oppgave med egenskap skjønnsfastsettelse dersom det finnes varsel om avvik`() { every { sykefraværstilfelle.kreverSkjønnsfastsettelse(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.SKJØNNSFASTSETTELSE)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, SKJØNNSFASTSETTELSE) } @Test fun `oppretter oppgave med egenskap tilbakedatert dersom det finnes varsel om tilbakedatering`() { every { sykefraværstilfelle.erTilbakedatert(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.TILBAKEDATERT)) - } - } - - @Test - fun `oppretter oppgave med egenskap haster dersom det er endring i utbetaling til sykmeldte`() { - every { utbetaling.harEndringIUtbetalingTilSykmeldt() } returns true - every { sykefraværstilfelle.haster(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() - assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.HASTER)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, TILBAKEDATERT) } @Test fun `oppretter oppgave med egen ansatt`() { every { egenAnsattRepository.erEgenAnsatt(FNR) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.EGEN_ANSATT)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, EGEN_ANSATT) } @Test fun `oppretter oppgave med egenskap spesialsak`() { every { vedtakDao.erSpesialsak(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.SPESIALSAK)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, SPESIALSAK) } @Test fun `oppretter oppgave med egenskap UTLAND`() { every { personRepository.finnEnhetId(FNR) } returns "0393" - val slot = slot<((Long) -> Oppgave)>() assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.UTLAND)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, UTLAND) } @Test fun `oppretter oppgave med egenskap FLERE_ARBEIDSGIVERE`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(opprettSaksbehandlerOppgaveCommand(inntektskilde = Inntektskilde.FLERE_ARBEIDSGIVERE).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.FLERE_ARBEIDSGIVERE)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, FLERE_ARBEIDSGIVERE, FORSTEGANGSBEHANDLING) } @Test fun `oppretter oppgave med egenskap FORLENGELSE`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(opprettSaksbehandlerOppgaveCommand(periodetype = FORLENGELSE).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.FORLENGELSE)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, Egenskap.FORLENGELSE) } @Test fun `oppretter oppgave med egenskap INFOTRYGDFORLENGELSE`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(opprettSaksbehandlerOppgaveCommand(periodetype = INFOTRYGDFORLENGELSE).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.INFOTRYGDFORLENGELSE)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, Egenskap.INFOTRYGDFORLENGELSE) } @Test fun `oppretter oppgave med egenskap OVERGANG_FRA_IT`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(opprettSaksbehandlerOppgaveCommand(periodetype = OVERGANG_FRA_IT).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.OVERGANG_FRA_IT)) - } + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, Egenskap.OVERGANG_FRA_IT) } @Test fun `oppretter oppgave med egenskap PÅ_VENT`() { every { påVentRepository.erPåVent(VEDTAKSPERIODE_ID) } returns true - val slot = slot<((Long) -> Oppgave)>() - assertTrue(opprettSaksbehandlerOppgaveCommand(periodetype = OVERGANG_FRA_IT).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - - val oppgave = slot.captured.invoke(1L) - oppgaveinspektør(oppgave) { - assertTrue(egenskaper.contains(EgenskapDto.PÅ_VENT)) - } + assertTrue(command.execute(context)) + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, PÅ_VENT) } @Test fun `legger ikke til egenskap RISK_QA hvis oppgaven har egenskap REVURDERING`() { every { risikovurderingRepository.kreverSupersaksbehandler(VEDTAKSPERIODE_ID) } returns true - utbetalingstype = Utbetalingtype.REVURDERING - val slot = slot<((Long) -> Oppgave)>() - assertTrue(command.execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } + assertTrue(opprettSaksbehandlerOppgaveCommand(utbetalingtype = Utbetalingtype.REVURDERING).execute(context)) - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(REVURDERING, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING), oppgave) + assertForventedeEgenskaper(REVURDERING, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING) } @Test fun `legger til oppgave med kanAvvises lik false`() { - val slot = slot<((Long) -> Oppgave)>() assertTrue(opprettSaksbehandlerOppgaveCommand(kanAvvises = false).execute(context)) - verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, capture(slot)) } - val oppgave = slot.captured.invoke(1L) - assertEquals(enOppgave(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, kanAvvises = false), oppgave) + assertForventedeEgenskaper(SØKNAD, INGEN_UTBETALING, EN_ARBEIDSGIVER, FORSTEGANGSBEHANDLING, kanAvvises = false) } - private fun enOppgave( - vararg egenskaper: Egenskap, - kanAvvises: Boolean = true, - ) = Oppgave.nyOppgave(1L, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), kanAvvises, egenskaper.toList()) + private fun assertForventedeEgenskaper(vararg egenskaper: Egenskap, kanAvvises: Boolean = true) { + verify(exactly = 1) { oppgaveService.nyOppgave(FNR, contextId, VEDTAKSPERIODE_ID, UTBETALING_ID, HENDELSE_ID, kanAvvises, egenskaper.toSet()) } + } private fun opprettSaksbehandlerOppgaveCommand( inntektskilde: Inntektskilde = Inntektskilde.EN_ARBEIDSGIVER, periodetype: Periodetype = FØRSTEGANGSBEHANDLING, + utbetalingtype: Utbetalingtype = Utbetalingtype.UTBETALING, kanAvvises: Boolean = true, ) = OpprettSaksbehandleroppgave( oppgaveService = oppgaveService, @@ -402,14 +267,14 @@ internal class OpprettSaksbehandleroppgaveTest { personRepository = personRepository, risikovurderingRepository = risikovurderingRepository, egenAnsattRepository = egenAnsattRepository, - utbetalingtype = utbetalingstype, + utbetalingtype = utbetalingtype, sykefraværstilfelle = sykefraværstilfelle, utbetaling = utbetaling, vergemålRepository = vergemålRepository, vedtakDao = vedtakDao, påVentRepository = påVentRepository, behovData = GodkjenningsbehovData( - id = UUID.randomUUID(), + id = HENDELSE_ID, fødselsnummer = FNR, aktørId = lagAktørId(), organisasjonsnummer = lagOrganisasjonsnummer(), @@ -424,7 +289,7 @@ internal class OpprettSaksbehandleroppgaveTest { periodeTom = 31.januar, periodetype = periodetype, førstegangsbehandling = true, - utbetalingtype = utbetalingstype, + utbetalingtype = utbetalingtype, kanAvvises = kanAvvises, inntektskilde = inntektskilde, orgnummereMedRelevanteArbeidsforhold = emptyList(), diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/oppgave/OppdaterOppgavestatusCommandTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/oppgave/OppdaterOppgavestatusCommandTest.kt index 3fb91ddc1..b61567ae2 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/oppgave/OppdaterOppgavestatusCommandTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/oppgave/OppdaterOppgavestatusCommandTest.kt @@ -28,7 +28,7 @@ internal class OppdaterOppgavestatusCommandTest { vedtaksperiodeId = UUID.randomUUID(), utbetalingId = UTBETALING_ID, hendelseId = UUID.randomUUID(), - egenskaper = listOf(SØKNAD), + egenskaper = setOf(SØKNAD), kanAvvises = true, ) }