From a6c5bde966d7c3d8810a6ad2bc11db79547cead1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christian=20B=C3=BClow=20Skovborg?= Date: Tue, 20 Aug 2024 12:37:38 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=94=A5=20Fjern=20diverse=20dao-funksjoner?= =?UTF-8?q?=20som=20ikke=20lenger=20er=20i=20bruk=20med=20tilh=C3=B8rende?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Oppdaget at OpprettMinimaltVedtakCommand ikke er i bruk, slettet denne også * Forenklet grensesnittet for å legge til en utbetaling på en vedtaksperiode --- .../kommando/OpprettMinimaltVedtakCommand.kt | 60 -- .../no/nav/helse/modell/person/Person.kt | 17 +- .../no/nav/helse/modell/varsel/VarselDao.kt | 144 ----- .../helse/modell/vedtaksperiode/Generasjon.kt | 9 +- .../modell/vedtaksperiode/GenerasjonDao.kt | 163 ----- .../modell/vedtaksperiode/Vedtaksperiode.kt | 7 +- .../VedtaksperiodeNyUtbetaling.kt | 2 +- .../test/kotlin/DatabaseIntegrationTest.kt | 67 +- .../kotlin/no/nav/helse/db/OppgaveDaoTest.kt | 190 +++--- .../mediator/SaksbehandlerMediatorTest.kt | 75 +-- .../no/nav/helse/modell/AvslagDaoTest.kt | 23 +- .../modell/kommando/CommandContextDaoTest.kt | 4 +- .../OpprettMinimaltVedtakCommandTest.kt | 80 --- .../Sykefrav\303\246rstilfelleTest.kt" | 4 +- .../nav/helse/modell/varsel/VarselDaoTest.kt | 386 ----------- .../vedtaksperiode/GenerasjonDaoTest.kt | 597 +----------------- .../modell/vedtaksperiode/GenerasjonTest.kt | 34 +- .../vedtaksperiode/GenerasjonTilstandTest.kt | 8 +- .../vedtaksperiode/VedtaksperiodeTest.kt | 8 +- 19 files changed, 223 insertions(+), 1655 deletions(-) delete mode 100644 spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommand.kt delete mode 100644 spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommandTest.kt delete mode 100644 spesialist-selve/src/test/kotlin/no/nav/helse/modell/varsel/VarselDaoTest.kt diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommand.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommand.kt deleted file mode 100644 index 7342d117d..000000000 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommand.kt +++ /dev/null @@ -1,60 +0,0 @@ -package no.nav.helse.modell.kommando - -import net.logstash.logback.argument.StructuredArguments.keyValue -import no.nav.helse.modell.VedtakDao -import no.nav.helse.modell.arbeidsgiver.ArbeidsgiverDao -import no.nav.helse.modell.person.PersonDao -import org.slf4j.LoggerFactory -import java.time.LocalDate -import java.util.UUID - -internal class OpprettMinimaltVedtakCommand( - private val fødselsnummer: String, - private val organisasjonsnummer: String, - private val vedtaksperiodeId: UUID, - private val periodeFom: LocalDate, - private val periodeTom: LocalDate, - private val personDao: PersonDao, - private val arbeidsgiverDao: ArbeidsgiverDao, - private val vedtakDao: VedtakDao, -) : Command { - private companion object { - private val sikkerlogg = LoggerFactory.getLogger("tjenestekall") - } - - override fun execute(context: CommandContext): Boolean { - val personRef = requireNotNull(personDao.findPersonByFødselsnummer(fødselsnummer)) - val arbeidsgiverRef = requireNotNull(arbeidsgiverDao.findArbeidsgiverByOrgnummer(organisasjonsnummer)) - if (vedtakDao.finnVedtakId(vedtaksperiodeId) != null) { - sikkerlogg.info( - "Oppretter ikke vedtaksperiode for {}, {}, {}, da denne finnes i databasen allerede", - keyValue("vedtaksperiodeId", vedtaksperiodeId), - keyValue("fødselsnummer", fødselsnummer), - keyValue("orgnummer", organisasjonsnummer), - ) - return true - } - return opprett(personRef, arbeidsgiverRef) - } - - private fun opprett( - personRef: Long, - arbeidsgiverRef: Long, - ): Boolean { - sikkerlogg.info( - "Oppretter minimal vedtaksperiode for {}, {}, {}", - keyValue("vedtaksperiodeId", vedtaksperiodeId), - keyValue("fødselsnummer", fødselsnummer), - keyValue("orgnummer", organisasjonsnummer), - ) - vedtakDao.opprett( - vedtaksperiodeId = vedtaksperiodeId, - fom = periodeFom, - tom = periodeTom, - personRef = personRef, - arbeidsgiverRef = arbeidsgiverRef, - ) - - return true - } -} diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/Person.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/Person.kt index e166bd55d..fa5a24abc 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/Person.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/Person.kt @@ -16,7 +16,6 @@ import no.nav.helse.modell.vedtaksperiode.Vedtaksperiode import no.nav.helse.modell.vedtaksperiode.Vedtaksperiode.Companion.relevanteFor import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeDto import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeForkastet -import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeNyUtbetaling import no.nav.helse.modell.vedtaksperiode.vedtak.VedtakFattet import no.nav.helse.modell.vilkårsprøving.Avviksvurdering import no.nav.helse.modell.vilkårsprøving.AvviksvurderingDto @@ -64,7 +63,12 @@ class Person private constructor( vedtaksperioder.forEach { it.nyttGodkjenningsbehov(perioder) } } - fun oppdaterPeriodeTilGodkjenning(vedtaksperiodeId: UUID, tags: List, spleisBehandlingId: UUID, utbetalingId: UUID) { + fun oppdaterPeriodeTilGodkjenning( + vedtaksperiodeId: UUID, + tags: List, + spleisBehandlingId: UUID, + utbetalingId: UUID, + ) { vedtaksperiode(vedtaksperiodeId)?.mottaBehandlingsinformasjon(tags, spleisBehandlingId, utbetalingId) } @@ -129,9 +133,12 @@ class Person private constructor( } } - internal fun nyUtbetalingForVedtaksperiode(vedtaksperiodeNyUtbetaling: VedtaksperiodeNyUtbetaling) { - vedtaksperiode(vedtaksperiodeNyUtbetaling.vedtaksperiodeId()) - ?.nyUtbetaling(vedtaksperiodeNyUtbetaling.id, vedtaksperiodeNyUtbetaling.utbetalingId) + internal fun nyUtbetalingForVedtaksperiode( + vedtaksperiodeId: UUID, + utbetalingId: UUID, + ) { + vedtaksperiode(vedtaksperiodeId) + ?.nyUtbetaling(utbetalingId) } companion object { diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/varsel/VarselDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/varsel/VarselDao.kt index 8babb43c5..89651dd10 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/varsel/VarselDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/varsel/VarselDao.kt @@ -3,7 +3,6 @@ package no.nav.helse.modell.varsel import kotliquery.queryOf import kotliquery.sessionOf import no.nav.helse.HelseDao -import no.nav.helse.modell.person.vedtaksperiode.Varsel import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status import org.intellij.lang.annotations.Language import java.time.LocalDateTime @@ -11,22 +10,6 @@ import java.util.UUID import javax.sql.DataSource internal class VarselDao(private val dataSource: DataSource) : HelseDao(dataSource) { - internal fun lagreVarsel( - varselId: UUID, - varselkode: String, - opprettet: LocalDateTime, - vedtaksperiodeId: UUID, - generasjonId: UUID, - ) { - @Language("PostgreSQL") - val query = - "INSERT INTO selve_varsel (unik_id, kode, vedtaksperiode_id, opprettet, generasjon_ref, definisjon_ref) VALUES (?, ?, ?, ?, (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?), null);" - - sessionOf(dataSource).use { session -> - session.run(queryOf(query, varselId, varselkode, vedtaksperiodeId, opprettet, generasjonId).asUpdate) - } - } - internal fun avvikleVarsel( varselkode: String, definisjonId: UUID, @@ -58,131 +41,4 @@ internal class VarselDao(private val dataSource: DataSource) : HelseDao(dataSour ) } } - - internal fun oppdaterStatus( - vedtaksperiodeId: UUID, - generasjonId: UUID, - varselkode: String, - status: Status, - ident: String?, - definisjonId: UUID?, - ) { - @Language("PostgreSQL") - val query = - """ - UPDATE selve_varsel - SET - status = :status, - status_endret_tidspunkt = :endretTidspunkt, - status_endret_ident = :ident, - definisjon_ref = case :definisjonId - when NULL then NULL - else (SELECT id FROM api_varseldefinisjon WHERE unik_id = :definisjonId) - end - WHERE vedtaksperiode_id = :vedtaksperiodeId - AND generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = :generasjonId) - AND kode = :varselkode - AND status != :status; - """ - - sessionOf(dataSource).use { session -> - session.run( - queryOf( - query, - mapOf( - "status" to status.name, - "endretTidspunkt" to LocalDateTime.now(), - "ident" to ident, - "definisjonId" to definisjonId, - "vedtaksperiodeId" to vedtaksperiodeId, - "generasjonId" to generasjonId, - "varselkode" to varselkode, - ), - ).asUpdate, - ).also { - check( - it > 0, - ) { "Varsel $varselkode for generasjonId $generasjonId, vedtaksperiodeId $vedtaksperiodeId har allerede status $status" } - } - } - } - - internal fun oppdaterGenerasjon( - id: UUID, - gammelGenerasjonId: UUID, - nyGenerasjonId: UUID, - ) { - @Language("PostgreSQL") - val query = """ - UPDATE selve_varsel - SET generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = :ny_generasjon_id) - WHERE unik_id = :id - AND generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = :gammel_generasjon_id) - """ - - sessionOf(dataSource).use { session -> - session.run( - queryOf( - query, - mapOf( - "ny_generasjon_id" to nyGenerasjonId, - "gammel_generasjon_id" to gammelGenerasjonId, - "id" to id, - ), - ).asUpdate, - ) - } - } - - internal fun finnVarselstatus( - vedtaksperiodeId: UUID, - varselkode: String, - ): Status? { - @Language("PostgreSQL") - val query = "SELECT status FROM selve_varsel WHERE vedtaksperiode_id = ? and kode = ?;" - - return sessionOf(dataSource).use { session -> - session.run( - queryOf(query, vedtaksperiodeId, varselkode).map { - enumValueOf(it.string(1)) - }.asSingle, - ) - } - } - - internal fun varslerFor(generasjonId: UUID): List { - @Language("PostgreSQL") - val query = - "SELECT unik_id, vedtaksperiode_id, kode, opprettet, status FROM selve_varsel WHERE generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?)" - return sessionOf(dataSource).use { session -> - session.run( - queryOf(query, generasjonId).map { - Varsel( - it.uuid("unik_id"), - it.string("kode"), - it.localDateTime("opprettet"), - it.uuid("vedtaksperiode_id"), - enumValueOf(it.string("status")), - ) - }.asList, - ) - } - } - - internal fun slettFor( - vedtaksperiodeId: UUID, - generasjonId: UUID, - varselkode: String, - ) = asSQL( - """ - delete from selve_varsel where vedtaksperiode_id = :vedtaksperiodeId - and kode = :varselkode - and generasjon_ref = (select id from selve_vedtaksperiode_generasjon where unik_id = :generasjonId) - """.trimIndent(), - mapOf( - "vedtaksperiodeId" to vedtaksperiodeId, - "generasjonId" to generasjonId, - "varselkode" to varselkode, - ), - ).update() } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Generasjon.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Generasjon.kt index 870a02bc2..66cc56ada 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Generasjon.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Generasjon.kt @@ -105,11 +105,8 @@ internal class Generasjon private constructor( internal fun automatiskGodkjennSpesialsakvarsler() = varsler.automatiskGodkjennSpesialsakvarsler() - internal fun håndterNyUtbetaling( - hendelseId: UUID, - utbetalingId: UUID, - ) { - tilstand.nyUtbetaling(this, hendelseId, utbetalingId) + internal fun håndterNyUtbetaling(utbetalingId: UUID) { + tilstand.nyUtbetaling(this, utbetalingId) } internal fun håndterForkastetUtbetaling(utbetalingId: UUID) { @@ -300,7 +297,6 @@ internal class Generasjon private constructor( fun nyUtbetaling( generasjon: Generasjon, - hendelseId: UUID, utbetalingId: UUID, ) { sikkerlogg.error( @@ -359,7 +355,6 @@ internal class Generasjon private constructor( override fun nyUtbetaling( generasjon: Generasjon, - hendelseId: UUID, utbetalingId: UUID, ) { generasjon.nyUtbetaling(utbetalingId) diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDao.kt index 9820062ed..fc20c3e66 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDao.kt @@ -1,11 +1,9 @@ package no.nav.helse.modell.vedtaksperiode import kotliquery.Query -import kotliquery.Row import kotliquery.TransactionalSession import kotliquery.queryOf import kotliquery.sessionOf -import no.nav.helse.modell.person.vedtaksperiode.Varsel import no.nav.helse.modell.person.vedtaksperiode.VarselDto import no.nav.helse.modell.person.vedtaksperiode.VarselStatusDto import org.intellij.lang.annotations.Language @@ -15,7 +13,6 @@ import java.util.UUID import javax.sql.DataSource class GenerasjonDao(private val dataSource: DataSource) { - internal fun TransactionalSession.finnGenerasjoner(vedtaksperiodeId: UUID): List { @Language("PostgreSQL") val query = """ @@ -59,18 +56,6 @@ class GenerasjonDao(private val dataSource: DataSource) { return tags } - internal fun lagre(generasjonDto: GenerasjonDto) { - sessionOf(dataSource).use { session -> - session.transaction { tx -> - tx.lagre(generasjonDto) - generasjonDto.varsler.forEach { varselDto -> - tx.lagre(varselDto, generasjonDto.vedtaksperiodeId, generasjonDto.id) - } - tx.slettVarsler(generasjonDto.id, generasjonDto.varsler.map { it.id }) - } - } - } - internal fun TransactionalSession.lagreGenerasjon(generasjonDto: GenerasjonDto) { this.lagre(generasjonDto) this.slettVarsler(generasjonDto.id, generasjonDto.varsler.map { it.id }) @@ -225,20 +210,12 @@ class GenerasjonDao(private val dataSource: DataSource) { } } - internal fun finnSisteGenerasjonFor(vedtaksperiodeId: UUID): UUID? { - return sessionOf(dataSource).use { session -> - session.run(finnSiste(vedtaksperiodeId).map { it.uuid("unik_id") }.asSingle) - } - } - internal fun finnSisteGenerasjonIdFor(vedtaksperiodeId: UUID): Long? { return sessionOf(dataSource).use { session -> session.run(finnSiste(vedtaksperiodeId).map { it.long("id") }.asSingle) } } - internal fun harGenerasjonFor(vedtaksperiodeId: UUID): Boolean = finnSisteGenerasjonFor(vedtaksperiodeId) != null - private fun finnSiste(vedtaksperiodeId: UUID): Query { @Language("PostgreSQL") val query = """ @@ -249,23 +226,6 @@ class GenerasjonDao(private val dataSource: DataSource) { return queryOf(query, vedtaksperiodeId) } - internal fun finnVedtaksperiodeIderFor( - fødselsnummer: String, - skjæringstidspunkt: LocalDate, - ): Set { - @Language("PostgreSQL") - val query = """ - SELECT svg.vedtaksperiode_id FROM selve_vedtaksperiode_generasjon svg - INNER JOIN vedtak v on svg.vedtaksperiode_id = v.vedtaksperiode_id - INNER JOIN person p on p.id = v.person_ref - WHERE fodselsnummer = ? AND svg.skjæringstidspunkt = ? AND forkastet = false - """ - - return sessionOf(dataSource).use { session -> - session.run(queryOf(query, fødselsnummer.toLong(), skjæringstidspunkt).map { it.uuid("vedtaksperiode_id") }.asList).toSet() - } - } - internal fun TransactionalSession.finnVedtaksperiodeIderFor(fødselsnummer: String): Set { @Language("PostgreSQL") val query = """ @@ -278,129 +238,6 @@ class GenerasjonDao(private val dataSource: DataSource) { return run(queryOf(query, fødselsnummer.toLong()).map { it.uuid("vedtaksperiode_id") }.asList).toSet() } - internal fun opprettFor( - id: UUID, - vedtaksperiodeId: UUID, - hendelseId: UUID, - skjæringstidspunkt: LocalDate, - periode: Periode, - tilstand: Generasjon.Tilstand, - utbetalingId: UUID?, - ): Generasjon { - @Language("PostgreSQL") - val query = """ - INSERT INTO selve_vedtaksperiode_generasjon (unik_id, vedtaksperiode_id, utbetaling_id, opprettet_av_hendelse, skjæringstidspunkt, fom, tom, tilstand) - VALUES (?, ?, ?, ?, ?, ?, ?, ?::generasjon_tilstand) - RETURNING id, unik_id, vedtaksperiode_id, utbetaling_id, spleis_behandling_id, skjæringstidspunkt, fom, tom, tilstand, tags - """ - - @Language("PostgreSQL") - val søknadMottattQuery = """ - INSERT INTO opprinnelig_soknadsdato - SELECT :vedtaksperiodeId, opprettet_tidspunkt - FROM selve_vedtaksperiode_generasjon - WHERE vedtaksperiode_id = :vedtaksperiodeId - ON CONFLICT DO NOTHING; - """ - - return sessionOf(dataSource).use { session -> - session.transaction { transactionalSession -> - val generasjon = - requireNotNull( - transactionalSession.run( - queryOf( - query, - id, - vedtaksperiodeId, - utbetalingId, - hendelseId, - skjæringstidspunkt, - periode.fom(), - periode.tom(), - tilstand.navn(), - ).map(::toGenerasjon).asSingle, - ), - ) { "Kunne ikke opprette ny generasjon" } - transactionalSession.run( - queryOf( - søknadMottattQuery, - mapOf( - "vedtaksperiodeId" to vedtaksperiodeId, - "soknadMottatt" to LocalDateTime.now(), - ), - ).asUpdate, - ) - generasjon - } - } - } - - private fun toGenerasjon(row: Row): Generasjon { - return Generasjon.fraLagring( - row.uuid("unik_id"), - row.uuid("vedtaksperiode_id"), - row.uuidOrNull("utbetaling_id"), - row.uuidOrNull("spleis_behandling_id"), - row.localDate("skjæringstidspunkt"), - row.localDate("fom"), - row.localDate("tom"), - mapToTilstand(row.string("tilstand")), - row.array("tags").toList(), - varslerFor(row.long("id")).toSet(), - ) - } - - private fun mapToTilstand(tilstand: String): Generasjon.Tilstand { - val tilstandKlasser = Generasjon.Tilstand::class.sealedSubclasses - val tilstander = tilstandKlasser.mapNotNull { it.objectInstance }.associateBy { it.navn() } - return tilstander.getValue(tilstand) - } - - private fun varslerFor(generasjonRef: Long): List { - @Language("PostgreSQL") - val query = - "SELECT unik_id, vedtaksperiode_id, kode, opprettet, status FROM selve_varsel WHERE generasjon_ref = ?" - return sessionOf(dataSource).use { session -> - session.run( - queryOf(query, generasjonRef).map { - Varsel( - it.uuid("unik_id"), - it.string("kode"), - it.localDateTime("opprettet"), - it.uuid("vedtaksperiode_id"), - enumValueOf(it.string("status")), - ) - }.asList, - ) - } - } - - internal fun oppdaterTilstandFor( - generasjonId: UUID, - ny: String, - endretAv: UUID, - ) { - @Language("PostgreSQL") - val query = """ - UPDATE selve_vedtaksperiode_generasjon - SET tilstand = :tilstand::generasjon_tilstand, tilstand_endret_tidspunkt = :endret_tidspunkt, tilstand_endret_av_hendelse = :endret_av_hendelse - WHERE unik_id = :generasjon_id - """ - sessionOf(dataSource).use { session -> - session.run( - queryOf( - query, - mapOf( - "tilstand" to ny, - "endret_tidspunkt" to LocalDateTime.now(), - "endret_av_hendelse" to endretAv, - "generasjon_id" to generasjonId, - ), - ).asUpdate, - ) - } - } - internal fun førsteGenerasjonVedtakFattetTidspunkt(vedtaksperiodeId: UUID): LocalDateTime? { @Language("PostgreSQL") val query = """ diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Vedtaksperiode.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Vedtaksperiode.kt index 96c401482..392b8176a 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Vedtaksperiode.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Vedtaksperiode.kt @@ -138,12 +138,9 @@ internal class Vedtaksperiode private constructor( gjeldendeGenerasjon.oppdaterBehandlingsinformasjon(tags, spleisBehandlingId, utbetalingId) } - internal fun nyUtbetaling( - meldingId: UUID, - utbetalingId: UUID, - ) { + internal fun nyUtbetaling(utbetalingId: UUID) { if (forkastet) return - gjeldendeGenerasjon.håndterNyUtbetaling(meldingId, utbetalingId) + gjeldendeGenerasjon.håndterNyUtbetaling(utbetalingId) } private fun finnes(spleisBehandling: SpleisBehandling): Boolean { diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeNyUtbetaling.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeNyUtbetaling.kt index c7fe080ad..f387fb053 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeNyUtbetaling.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeNyUtbetaling.kt @@ -41,7 +41,7 @@ internal class VedtaksperiodeNyUtbetaling private constructor( person: Person, kommandofabrikk: Kommandofabrikk, ) { - person.nyUtbetalingForVedtaksperiode(this) + person.nyUtbetalingForVedtaksperiode(vedtaksperiodeId = vedtaksperiodeId, utbetalingId = utbetalingId) kommandofabrikk.iverksettVedtaksperiodeNyUtbetaling(this) } diff --git a/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt b/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt index a084b391f..ad45e2d72 100644 --- a/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt +++ b/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt @@ -31,18 +31,18 @@ import no.nav.helse.modell.gosysoppgaver.ÅpneGosysOppgaverDao import no.nav.helse.modell.kommando.TestMelding import no.nav.helse.modell.overstyring.OverstyringDao import no.nav.helse.modell.person.PersonDao +import no.nav.helse.modell.person.PersonRepository import no.nav.helse.modell.påvent.PåVentDao import no.nav.helse.modell.risiko.RisikovurderingDao import no.nav.helse.modell.utbetaling.UtbetalingDao import no.nav.helse.modell.utbetaling.Utbetalingsstatus import no.nav.helse.modell.utbetaling.Utbetalingtype -import no.nav.helse.modell.vedtaksperiode.Generasjon import no.nav.helse.modell.vedtaksperiode.GenerasjonDao import no.nav.helse.modell.vedtaksperiode.Inntektskilde import no.nav.helse.modell.vedtaksperiode.Inntektskilde.EN_ARBEIDSGIVER -import no.nav.helse.modell.vedtaksperiode.Periode import no.nav.helse.modell.vedtaksperiode.Periodetype import no.nav.helse.modell.vedtaksperiode.Periodetype.FØRSTEGANGSBEHANDLING +import no.nav.helse.modell.vedtaksperiode.SpleisBehandling import no.nav.helse.modell.vergemal.VergemålDao import no.nav.helse.spesialist.api.abonnement.AbonnementDao import no.nav.helse.spesialist.api.abonnement.OpptegnelseDao @@ -64,7 +64,6 @@ import no.nav.helse.spleis.graphql.hentsnapshot.GraphQLPerson import no.nav.helse.spleis.graphql.hentsnapshot.GraphQLUberegnetPeriode import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Assertions -import org.junit.jupiter.api.fail import java.time.LocalDate import java.time.LocalDateTime import java.util.Random @@ -166,6 +165,7 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { internal val stansAutomatiskBehandlingDao = StansAutomatiskBehandlingDao(dataSource) internal val notatDao = NotatDao(dataSource) internal val annulleringDao = AnnulleringDao(dataSource) + internal val personRepository = PersonRepository(dataSource) internal fun testhendelse( hendelseId: UUID = HENDELSE_ID, @@ -220,18 +220,19 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { organisasjonsnummer: String = ORGNUMMER, vedtaksperiodeId: UUID = VEDTAKSPERIODE, utbetalingId: UUID = UTBETALING_ID, - generasjonId: UUID = UUID.randomUUID(), contextId: UUID = UUID.randomUUID(), hendelseId: UUID = UUID.randomUUID(), oppgaveEgenskaper: List = listOf(EGENSKAP), ) { opprettPerson(fødselsnummer = fødselsnummer, aktørId = aktørId) opprettArbeidsgiver(organisasjonsnummer = organisasjonsnummer) - opprettGenerasjon(generasjonId = generasjonId, vedtaksperiodeId = vedtaksperiodeId, utbetalingId = utbetalingId) opprettVedtaksperiode( + fødselsnummer = fødselsnummer, + organisasjonsnummer = organisasjonsnummer, vedtaksperiodeId = vedtaksperiodeId, periodetype = periodetype, inntektskilde = inntektskilde, + utbetalingId = utbetalingId, ) opprettOppgave( contextId = contextId, @@ -324,39 +325,34 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { protected fun opprettGenerasjon( vedtaksperiodeId: UUID = VEDTAKSPERIODE, - generasjonId: UUID = UUID.randomUUID(), - utbetalingId: UUID? = null, + spleisBehandlingId: UUID = UUID.randomUUID(), ) { - generasjonDao.finnSisteGenerasjonFor(vedtaksperiodeId)?.also { - generasjonDao.oppdaterTilstandFor(generasjonId = it, ny = Generasjon.VedtakFattet.navn(), endretAv = UUID.randomUUID()) + personRepository.brukPersonHvisFinnes(FNR) { + this.nySpleisBehandling(SpleisBehandling(ORGNUMMER, vedtaksperiodeId, spleisBehandlingId, 1.januar, 31.januar)) } - generasjonDao.opprettFor( - generasjonId, - vedtaksperiodeId, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - utbetalingId, - ) } protected fun opprettVedtaksperiode( + fødselsnummer: String = FNR, + organisasjonsnummer: String = ORGNUMMER, vedtaksperiodeId: UUID = VEDTAKSPERIODE, fom: LocalDate = FOM, tom: LocalDate = TOM, periodetype: Periodetype = FØRSTEGANGSBEHANDLING, inntektskilde: Inntektskilde = EN_ARBEIDSGIVER, + utbetalingId: UUID? = UTBETALING_ID, forkastet: Boolean = false, - ): Long { - return vedtakDao.opprett(vedtaksperiodeId, fom, tom, personId, arbeidsgiverId) - .let { vedtakDao.finnVedtakId(vedtaksperiodeId) } - ?.also { - vedtakId = it - opprettVedtakstype(vedtaksperiodeId, periodetype, inntektskilde) - if (forkastet) vedtakDao.markerForkastet(vedtaksperiodeId, UUID.randomUUID()) - } - ?: fail { "Kunne ikke opprette vedtak" } + spleisBehandlingId: UUID = UUID.randomUUID(), + ) { + personRepository.brukPersonHvisFinnes(fødselsnummer) { + this.nySpleisBehandling(SpleisBehandling(organisasjonsnummer, vedtaksperiodeId, spleisBehandlingId, fom, tom)) + if (utbetalingId != null) this.nyUtbetalingForVedtaksperiode(vedtaksperiodeId, utbetalingId) + } + vedtakDao.finnVedtakId(vedtaksperiodeId)?.also { + vedtakId = it + } + opprettVedtakstype(vedtaksperiodeId, periodetype, inntektskilde) + if (forkastet) vedtakDao.markerForkastet(vedtaksperiodeId, UUID.randomUUID()) } protected fun opprettOppgave( @@ -556,7 +552,6 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { id: UUID = UUID.randomUUID(), vedtaksperiodeId: UUID = UUID.randomUUID(), kode: String = "EN_KODE", - generasjonId: UUID, definisjonRef: Long? = null, status: String, endretTidspunkt: LocalDateTime? = LocalDateTime.now(), @@ -564,7 +559,7 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { @Language("PostgreSQL") val query = """ INSERT INTO selve_varsel(unik_id, kode, vedtaksperiode_id, generasjon_ref, definisjon_ref, opprettet, status, status_endret_ident, status_endret_tidspunkt) - VALUES (?, ?, ?, (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?), ?, ?, ?, ?, ?) + VALUES (?, ?, ?, (SELECT id FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ? LIMIT 1), ?, ?, ?, ?, ?) """ session.run( queryOf( @@ -572,7 +567,7 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { id, kode, vedtaksperiodeId, - generasjonId, + vedtaksperiodeId, definisjonRef, LocalDateTime.now(), status, @@ -622,29 +617,29 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { ).execute() protected fun assertGodkjenteVarsler( - generasjonId: UUID, + vedtaksperiodeId: UUID, forventetAntall: Int, ) { @Language("PostgreSQL") val query = - "SELECT COUNT(1) FROM selve_varsel sv WHERE sv.generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?) AND status = 'GODKJENT'" + "SELECT COUNT(1) FROM selve_varsel sv WHERE sv.generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ?) AND status = 'GODKJENT'" val antall = sessionOf(dataSource).use { session -> - session.run(queryOf(query, generasjonId).map { it.int(1) }.asSingle) + session.run(queryOf(query, vedtaksperiodeId).map { it.int(1) }.asSingle) } Assertions.assertEquals(forventetAntall, antall) } protected fun assertAvvisteVarsler( - generasjonId: UUID, + vedtaksperiodeId: UUID, forventetAntall: Int, ) { @Language("PostgreSQL") val query = - "SELECT COUNT(1) FROM selve_varsel sv WHERE sv.generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?) AND status = 'AVVIST'" + "SELECT COUNT(1) FROM selve_varsel sv WHERE sv.generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ?) AND status = 'AVVIST'" val antall = sessionOf(dataSource).use { session -> - session.run(queryOf(query, generasjonId).map { it.int(1) }.asSingle) + session.run(queryOf(query, vedtaksperiodeId).map { it.int(1) }.asSingle) } Assertions.assertEquals(forventetAntall, antall) } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/db/OppgaveDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/db/OppgaveDaoTest.kt index 1440ad31f..cf0aa0e7e 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/db/OppgaveDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/db/OppgaveDaoTest.kt @@ -284,7 +284,12 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { val arbeidsgiver = lagOrganisasjonsnummer() val vedtaksperiodeId = UUID.randomUUID() val saksbehandlerOid = UUID.randomUUID() - nyPerson(fødselsnummer = fnr, aktørId = aktørId, vedtaksperiodeId = vedtaksperiodeId, organisasjonsnummer = arbeidsgiver) + nyPerson( + fødselsnummer = fnr, + aktørId = aktørId, + organisasjonsnummer = arbeidsgiver, + vedtaksperiodeId = vedtaksperiodeId + ) tildelOppgave(saksbehandlerOid = saksbehandlerOid) val oppgaver = oppgaveDao.finnOppgaverForVisning(emptyList(), UUID.randomUUID()) assertEquals(1, oppgaver.size) @@ -337,8 +342,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) tildelOppgave(saksbehandlerOid = saksbehandlerOid) ferdigstillOppgave(OPPGAVE_ID, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -346,8 +351,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) tildelOppgave(saksbehandlerOid = saksbehandlerOid) ferdigstillOppgave(OPPGAVE_ID, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -355,8 +360,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) tildelOppgave(saksbehandlerOid = saksbehandlerOid) avventerSystem(OPPGAVE_ID, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -364,8 +369,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) tildelOppgave(saksbehandlerOid = annenSaksbehandlerOid) ferdigstillOppgave(OPPGAVE_ID, ferdigstiltAvOid = annenSaksbehandlerOid, ferdigstiltAv = "ANNEN_SAKSBEHANDLER") @@ -381,7 +386,12 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { val beslutterOid = UUID.randomUUID() val annenSaksbehandlerOid = UUID.randomUUID() - nyPerson(fødselsnummer = FNR, aktørId = AKTØR, vedtaksperiodeId = VEDTAKSPERIODE, organisasjonsnummer = ORGNUMMER) + nyPerson( + fødselsnummer = FNR, + aktørId = AKTØR, + organisasjonsnummer = ORGNUMMER, + vedtaksperiodeId = VEDTAKSPERIODE + ) utbetalingsopplegg(1000, 0) opprettSaksbehandler(saksbehandlerOID = saksbehandlerOid) opprettSaksbehandler(beslutterOid, navn = "NAVN TIL BESLUTTER") @@ -405,20 +415,20 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaver = oppgaveDao.finnOppgaverForVisning(emptyList(), UUID.randomUUID()) assertEquals(3, oppgaver.size) @@ -429,22 +439,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf(SØKNAD, RISK_QA, FORTROLIG_ADRESSE), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf(RISK_QA, SØKNAD), ) val oppgaveId3 = OPPGAVE_ID @@ -467,21 +477,21 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf(SØKNAD), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf(RISK_QA), ) val oppgaver = @@ -502,22 +512,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaver = oppgaveDao.finnOppgaverForVisning(emptyList(), UUID.randomUUID(), 1, 2) assertEquals(2, oppgaver.size) @@ -530,8 +540,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID ferdigstillOppgave(oppgaveId1, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -539,8 +549,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID ferdigstillOppgave(oppgaveId2, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -548,8 +558,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID ferdigstillOppgave(oppgaveId3, ferdigstiltAvOid = saksbehandlerOid, ferdigstiltAv = SAKSBEHANDLER_NAVN) @@ -564,22 +574,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID avventerSystem(oppgaveId3, ferdigstiltAv = "navn", ferdigstiltAvOid = UUID.randomUUID()) @@ -593,22 +603,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID val oppgaver = @@ -629,22 +639,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID val oppgaver = @@ -665,22 +675,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID val oppgaver = @@ -701,22 +711,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID val oppgaver = @@ -737,23 +747,23 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, UUID.randomUUID(), "A") nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID tildelOppgave(oppgaveId3, UUID.randomUUID(), "B") @@ -775,23 +785,23 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, UUID.randomUUID(), "A") nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID tildelOppgave(oppgaveId3, UUID.randomUUID(), "B") @@ -813,23 +823,23 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, UUID.randomUUID(), "A") nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID val saksbehandlerOid2 = UUID.randomUUID() @@ -837,8 +847,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId4 = OPPGAVE_ID tildelOppgave(oppgaveId4, saksbehandlerOid2, "B") @@ -861,15 +871,15 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( BESLUTTER, @@ -878,8 +888,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( RISK_QA, @@ -900,15 +910,15 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( BESLUTTER, @@ -917,8 +927,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( RISK_QA, @@ -928,8 +938,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( UTLAND, @@ -950,22 +960,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, saksbehandlerOid = UUID.randomUUID()) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaver = oppgaveDao.finnOppgaverForVisning(emptyList(), UUID.randomUUID(), tildelt = true) @@ -979,23 +989,23 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, saksbehandlerOid = UUID.randomUUID()) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID @@ -1010,23 +1020,23 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, saksbehandlerOid = UUID.randomUUID()) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID @@ -1041,22 +1051,22 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( RISK_QA, @@ -1076,16 +1086,16 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId1, saksbehandlerOid = saksbehandlerOid) nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf(PÅ_VENT), ) val oppgaveId2 = OPPGAVE_ID @@ -1093,8 +1103,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID @@ -1134,8 +1144,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = vedtaksperiodeId, organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = vedtaksperiodeId, oppgaveEgenskaper = listOf( BESLUTTER, @@ -1154,8 +1164,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = vedtaksperiodeId, organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = vedtaksperiodeId, oppgaveEgenskaper = listOf( STRENGT_FORTROLIG_ADRESSE, @@ -1176,8 +1186,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( SØKNAD, @@ -1192,8 +1202,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( REVURDERING, @@ -1203,8 +1213,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( SØKNAD, @@ -1214,8 +1224,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( UTBETALING_TIL_SYKMELDT, @@ -1281,8 +1291,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( SØKNAD, @@ -1296,8 +1306,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), oppgaveEgenskaper = listOf( SØKNAD, @@ -1442,10 +1452,14 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { val fnr2 = lagFødselsnummer() val aktørId2 = lagAktørId() + val organisasjonsnummer2 = lagOrganisasjonsnummer() val vedtaksperiodeId2 = UUID.randomUUID() opprettPerson(fødselsnummer = fnr2, aktørId2) - opprettArbeidsgiver(lagOrganisasjonsnummer(), "en annen bedrift") - opprettVedtaksperiode(vedtaksperiodeId = vedtaksperiodeId2) + opprettArbeidsgiver(organisasjonsnummer2, "en annen bedrift") + opprettVedtaksperiode( + fødselsnummer = fnr2, + organisasjonsnummer = organisasjonsnummer2, + vedtaksperiodeId = vedtaksperiodeId2) opprettOppgave(vedtaksperiodeId = vedtaksperiodeId2, utbetalingId = UUID.randomUUID()) val oppgaveId2 = oppgaveId @@ -1467,8 +1481,14 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { val vedtaksperiodeId2 = UUID.randomUUID() val utbetalingId2 = UUID.randomUUID() opprettPerson(fødselsnummer = fnr2, aktørId2) - opprettArbeidsgiver(lagOrganisasjonsnummer(), "en annen bedrift") - opprettVedtaksperiode(vedtaksperiodeId = vedtaksperiodeId2) + val organisasjonsnummer2 = lagOrganisasjonsnummer() + opprettArbeidsgiver(organisasjonsnummer2, "en annen bedrift") + opprettVedtaksperiode( + fødselsnummer = fnr2, + vedtaksperiodeId = vedtaksperiodeId2, + organisasjonsnummer = organisasjonsnummer2, + utbetalingId = utbetalingId2 + ) opprettOppgave( vedtaksperiodeId = vedtaksperiodeId2, egenskaper = listOf(SØKNAD, PÅ_VENT), @@ -1491,8 +1511,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId1 = OPPGAVE_ID tildelOppgave(oppgaveId = oppgaveId1, saksbehandlerOid = saksbehandlerOid) @@ -1500,8 +1520,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId2 = OPPGAVE_ID tildelOppgave(oppgaveId = oppgaveId2, saksbehandlerOid = saksbehandlerOid) @@ -1509,8 +1529,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId3 = OPPGAVE_ID tildelOppgave(oppgaveId = oppgaveId3, saksbehandlerOid = saksbehandlerOid, egenskaper = listOf(SØKNAD, PÅ_VENT)) @@ -1518,8 +1538,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = UUID.randomUUID(), organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = UUID.randomUUID(), ) val oppgaveId4 = OPPGAVE_ID tildelOppgave(oppgaveId = oppgaveId4, saksbehandlerOid = UUID.randomUUID(), egenskaper = listOf(SØKNAD, PÅ_VENT)) @@ -1539,8 +1559,8 @@ class OppgaveDaoTest : DatabaseIntegrationTest() { nyPerson( fødselsnummer = lagFødselsnummer(), aktørId = lagAktørId(), - vedtaksperiodeId = vedtaksperiodeId1, organisasjonsnummer = lagOrganisasjonsnummer(), + vedtaksperiodeId = vedtaksperiodeId1, ) val antallOppgaver = oppgaveDao.finnAntallOppgaver(saksbehandlerOid) diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/SaksbehandlerMediatorTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/SaksbehandlerMediatorTest.kt index 4eb8f3f66..00ee66583 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/SaksbehandlerMediatorTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/mediator/SaksbehandlerMediatorTest.kt @@ -113,64 +113,57 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndter godkjenning`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon() nyttVarsel( vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "VURDERT", definisjonRef = definisjonRef, + status = "VURDERT", ) nyttVarsel( - kode = "EN_ANNEN_KODE", vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "VURDERT", + kode = "EN_ANNEN_KODE", definisjonRef = definisjonRef, + status = "VURDERT", ) assertDoesNotThrow { mediator.håndter(godkjenning(oppgaveId, true), UUID.randomUUID(), saksbehandler) } - assertGodkjenteVarsler(generasjonId, 2) + assertGodkjenteVarsler(vedtaksperiodeId, 2) } @Test fun `håndter godkjenning når periode har aktivt varsel`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(generasjonId = generasjonId, vedtaksperiodeId = vedtaksperiodeId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon() nyttVarsel( vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "AKTIV", definisjonRef = definisjonRef, + status = "AKTIV", ) assertThrows { mediator.håndter(godkjenning(oppgaveId, true), UUID.randomUUID(), saksbehandler) } - assertGodkjenteVarsler(generasjonId, 0) + assertGodkjenteVarsler(vedtaksperiodeId, 0) } @Test fun `håndter godkjenning når periode ikke har noen varsler`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) assertDoesNotThrow { mediator.håndter(godkjenning(OPPGAVE_ID, true), UUID.randomUUID(), saksbehandler) } - assertGodkjenteVarsler(generasjonId, 0) + assertGodkjenteVarsler(vedtaksperiodeId, 0) } @Test fun `invalider eksisterende oppgave ved overstyring`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) mediator.håndter( TidslinjeOverstyring(VEDTAKSPERIODE, ORGANISASJONSNUMMER, FNR, AKTØR, "", dager = emptyList()), saksbehandler, @@ -181,32 +174,28 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndter godkjenning når godkjenning er avvist`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon() nyttVarsel( vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "AKTIV", definisjonRef = definisjonRef, + status = "AKTIV", ) mediator.håndter(godkjenning(oppgaveId, false), UUID.randomUUID(), saksbehandler) - assertGodkjenteVarsler(generasjonId, 0) - assertAvvisteVarsler(generasjonId, 1) + assertGodkjenteVarsler(vedtaksperiodeId, 0) + assertAvvisteVarsler(vedtaksperiodeId, 1) } @Test fun `håndter totrinnsvurdering`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon() nyttVarsel( vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "VURDERT", definisjonRef = definisjonRef, + status = "VURDERT", ) assertDoesNotThrow { mediator.håndterTotrinnsvurdering(oppgaveId) @@ -216,14 +205,12 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndter totrinnsvurdering når periode har aktivt varsel`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon() nyttVarsel( vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, - status = "AKTIV", definisjonRef = definisjonRef, + status = "AKTIV", ) assertThrows { mediator.håndterTotrinnsvurdering(oppgaveId) @@ -242,8 +229,7 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndterer godkjenning med avslag`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) assertDoesNotThrow { mediator.håndter( @@ -265,8 +251,7 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndterer på vent`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) påVentDao.lagrePåVent(oppgaveId, saksbehandler.oid, LocalDate.now(), "") assertDoesNotThrow { mediator.håndter(godkjenning(oppgaveId, true), UUID.randomUUID(), saksbehandler) @@ -277,18 +262,16 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `sender ut varsel_endret ved godkjenning av varsler`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() val varselId = UUID.randomUUID() val behandlingId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon(tittel = "EN_TITTEL") nyttVarsel( id = varselId, vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, kode = "EN_KODE", - status = "VURDERT", definisjonRef = definisjonRef, + status = "VURDERT", ) mediator.håndter(godkjenning(oppgaveId, true), behandlingId, saksbehandler) @@ -307,18 +290,16 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `sender ut varsel_endret ved avvisning av varsler`() { val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() val varselId = UUID.randomUUID() val behandlingId = UUID.randomUUID() - nyPerson(vedtaksperiodeId = vedtaksperiodeId, generasjonId = generasjonId) + nyPerson(vedtaksperiodeId = vedtaksperiodeId) val definisjonRef = opprettVarseldefinisjon(tittel = "EN_TITTEL") nyttVarsel( id = varselId, vedtaksperiodeId = vedtaksperiodeId, - generasjonId = generasjonId, kode = "EN_KODE", - status = "AKTIV", definisjonRef = definisjonRef, + status = "AKTIV", ) mediator.håndter(godkjenning(oppgaveId, false), behandlingId, saksbehandler) @@ -537,7 +518,7 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndterer overstyring av arbeidsforhold`() { - nyPerson(fødselsnummer = FØDSELSNUMMER, organisasjonsnummer = ORGANISASJONSNUMMER, aktørId = AKTØR_ID) + nyPerson(fødselsnummer = FØDSELSNUMMER, aktørId = AKTØR_ID, organisasjonsnummer = ORGANISASJONSNUMMER) val overstyring = ArbeidsforholdOverstyringHandling( fodselsnummer = FØDSELSNUMMER, @@ -577,7 +558,7 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndterer overstyring av inntekt og refusjon`() { - nyPerson(fødselsnummer = FØDSELSNUMMER, organisasjonsnummer = ORGANISASJONSNUMMER, aktørId = AKTØR_ID) + nyPerson(fødselsnummer = FØDSELSNUMMER, aktørId = AKTØR_ID, organisasjonsnummer = ORGANISASJONSNUMMER) val overstyring = InntektOgRefusjonOverstyring( fodselsnummer = FØDSELSNUMMER, @@ -663,7 +644,7 @@ internal class SaksbehandlerMediatorTest : DatabaseIntegrationTest() { @Test fun `håndterer skjønnsfastsetting av sykepengegrunnlag`() { - nyPerson(fødselsnummer = FØDSELSNUMMER, organisasjonsnummer = ORGANISASJONSNUMMER, aktørId = AKTØR_ID) + nyPerson(fødselsnummer = FØDSELSNUMMER, aktørId = AKTØR_ID, organisasjonsnummer = ORGANISASJONSNUMMER) val skjønnsfastsetting = Skjonnsfastsettelse( fodselsnummer = FØDSELSNUMMER, diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/AvslagDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/AvslagDaoTest.kt index c59812557..a85d3b4d7 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/AvslagDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/AvslagDaoTest.kt @@ -22,25 +22,25 @@ internal class AvslagDaoTest : DatabaseIntegrationTest() { @Test fun `lagrer og finner avslag`() { val oid = UUID.randomUUID() - val generasjonUnikId = UUID.randomUUID() - nyPerson(generasjonId = generasjonUnikId) + val vedtaksperiodeId = UUID.randomUUID() + nyPerson(vedtaksperiodeId = vedtaksperiodeId) nySaksbehandler(oid) val avslag = Avslag(handling = Avslagshandling.OPPRETT, data = Avslagsdata(Avslagstype.AVSLAG, "En individuell begrunelse")) nyDao.lagreAvslag(OPPGAVE_ID, avslag.data!!, oid) - val generasjonId = finnGenereasjonId(generasjonUnikId) + val generasjonId = finnGenerasjonId(vedtaksperiodeId) - val lagretAvslag = nyDao.finnAvslag(VEDTAKSPERIODE, generasjonId) + val lagretAvslag = nyDao.finnAvslag(vedtaksperiodeId, generasjonId) assertNotNull(lagretAvslag) } @Test fun `invaliderer avslag`() { val oid = UUID.randomUUID() - val generasjonUnikId = UUID.randomUUID() - nyPerson(generasjonId = generasjonUnikId) + val vedtaksperiodeId = UUID.randomUUID() + nyPerson(vedtaksperiodeId = vedtaksperiodeId) nySaksbehandler(oid) - val generasjonId = finnGenereasjonId(generasjonUnikId) + val generasjonId = finnGenerasjonId(vedtaksperiodeId) val avslag = Avslag(handling = Avslagshandling.OPPRETT, data = Avslagsdata(Avslagstype.AVSLAG, "En individuell begrunelse")) nyDao.lagreAvslag(OPPGAVE_ID, avslag.data!!, oid) nyDao.invaliderAvslag(OPPGAVE_ID) @@ -49,10 +49,9 @@ internal class AvslagDaoTest : DatabaseIntegrationTest() { } @Test - fun `finner alle Avslag for periode`() { + fun `finner alle avslag for periode`() { val oid = UUID.randomUUID() - val generasjonUnikId = UUID.randomUUID() - nyPerson(generasjonId = generasjonUnikId) + nyPerson() nySaksbehandler(oid) val avslag = Avslag(handling = Avslagshandling.OPPRETT, data = Avslagsdata(Avslagstype.AVSLAG, "En individuell begrunelse")) val avslag2 = Avslag(handling = Avslagshandling.OPPRETT, data = Avslagsdata(Avslagstype.DELVIS_AVSLAG, "En individuell begrunelse delvis avslag retter skrivefeil")) @@ -78,11 +77,11 @@ internal class AvslagDaoTest : DatabaseIntegrationTest() { saksbehandlerDao.opprettSaksbehandler(oid, "Navn Navnesen", "navn@navnesen.no", "Z999999") } - private fun finnGenereasjonId(unikId: UUID): Long = + private fun finnGenerasjonId(vedtaksperiodeId: UUID): Long = requireNotNull( sessionOf(dataSource).use { session -> session.run( - queryOf("SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?", unikId) + queryOf("SELECT id FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ?", vedtaksperiodeId) .map { it.long("id") }.asSingle ) } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/CommandContextDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/CommandContextDaoTest.kt index c48447cc8..4ece55d87 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/CommandContextDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/CommandContextDaoTest.kt @@ -133,8 +133,8 @@ internal class CommandContextDaoTest : DatabaseIntegrationTest() { HENDELSE2 = testhendelse(UUID.randomUUID(), vedtaksperiodeId = VEDTAKSPERIODE_ID2) opprettPerson() opprettArbeidsgiver() - opprettVedtaksperiode(VEDTAKSPERIODE_ID1) - opprettVedtaksperiode(VEDTAKSPERIODE_ID2) + opprettVedtaksperiode(vedtaksperiodeId = VEDTAKSPERIODE_ID1) + opprettVedtaksperiode(vedtaksperiodeId = VEDTAKSPERIODE_ID2) vedtakDao.opprettKobling(VEDTAKSPERIODE_ID1, HENDELSE1.id) vedtakDao.opprettKobling(VEDTAKSPERIODE_ID2, HENDELSE2.id) } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommandTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommandTest.kt deleted file mode 100644 index f2e09baa4..000000000 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/kommando/OpprettMinimaltVedtakCommandTest.kt +++ /dev/null @@ -1,80 +0,0 @@ -package no.nav.helse.modell.kommando - -import io.mockk.clearMocks -import io.mockk.every -import io.mockk.mockk -import io.mockk.verify -import java.time.LocalDate -import java.util.UUID -import no.nav.helse.modell.SnapshotDao -import no.nav.helse.modell.VedtakDao -import no.nav.helse.modell.arbeidsgiver.ArbeidsgiverDao -import no.nav.helse.modell.person.PersonDao -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.api.Test - -internal class OpprettMinimaltVedtakCommandTest { - private companion object { - private const val FNR = "12345678911" - private const val ORGNR = "123456789" - private val VEDTAKSPERIODE_ID = UUID.randomUUID() - private val FOM = LocalDate.of(2020, 1, 1) - private val TOM = LocalDate.of(2020, 1, 31) - } - - private lateinit var context: CommandContext - private val personDao = mockk(relaxed = true) - private val arbeidsgiverDao = mockk(relaxed = true) - private val snapshotDao = mockk(relaxed = true) - private val vedtakDao = mockk(relaxed = true) - private val command = OpprettMinimaltVedtakCommand( - fødselsnummer = FNR, - organisasjonsnummer = ORGNR, - vedtaksperiodeId = VEDTAKSPERIODE_ID, - periodeFom = FOM, - periodeTom = TOM, - personDao = personDao, - arbeidsgiverDao = arbeidsgiverDao, - vedtakDao = vedtakDao, - ) - - @BeforeEach - fun setup() { - context = CommandContext(UUID.randomUUID()) - clearMocks(personDao, arbeidsgiverDao, snapshotDao, vedtakDao) - } - - @Test - fun `oppretter vedtaksperiode`() { - val (personRef, arbeidsgiverRef) = personFinnes() - every { vedtakDao.finnVedtakId(VEDTAKSPERIODE_ID) } returns null - assertTrue(command.execute(context)) - verify(exactly = 1) { - vedtakDao.opprett( - vedtaksperiodeId = VEDTAKSPERIODE_ID, - fom = FOM, - tom = TOM, - personRef = personRef, - arbeidsgiverRef = arbeidsgiverRef - ) - } - } - - @Test - fun `oppretter ikke vedtaksperiode dersom denne finnes fra før`() { - every { vedtakDao.finnVedtakId(VEDTAKSPERIODE_ID) } returns 1L - assertTrue(command.execute(context)) - verify(exactly = 0) { - vedtakDao.opprett(any(), any(), any(), any(), any()) - } - } - - private fun personFinnes(): Pair { - val personRef = 1L - val arbeidsgiverRef = 2L - every { personDao.findPersonByFødselsnummer(FNR) } returns personRef - every { arbeidsgiverDao.findArbeidsgiverByOrgnummer(ORGNR) } returns arbeidsgiverRef - return Pair(personRef, arbeidsgiverRef) - } -} diff --git "a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/sykefrav\303\246rstilfelle/Sykefrav\303\246rstilfelleTest.kt" "b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/sykefrav\303\246rstilfelle/Sykefrav\303\246rstilfelleTest.kt" index 1f9eba754..767cccf7f 100644 --- "a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/sykefrav\303\246rstilfelle/Sykefrav\303\246rstilfelleTest.kt" +++ "b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/sykefrav\303\246rstilfelle/Sykefrav\303\246rstilfelleTest.kt" @@ -33,8 +33,8 @@ internal class SykefraværstilfelleTest { val gjeldendeGenerasjon1 = generasjon(UUID.randomUUID()) val gjeldendeGenerasjon2 = generasjon(UUID.randomUUID()) val utbetalingId = UUID.randomUUID() - gjeldendeGenerasjon1.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) - gjeldendeGenerasjon2.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + gjeldendeGenerasjon1.håndterNyUtbetaling(utbetalingId) + gjeldendeGenerasjon2.håndterNyUtbetaling(utbetalingId) assertFalse(listOf(gjeldendeGenerasjon1, gjeldendeGenerasjon2).forhindrerAutomatisering(28.februar)) } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/varsel/VarselDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/varsel/VarselDaoTest.kt deleted file mode 100644 index bcecc393d..000000000 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/varsel/VarselDaoTest.kt +++ /dev/null @@ -1,386 +0,0 @@ -package no.nav.helse.modell.varsel - -import DatabaseIntegrationTest -import kotliquery.queryOf -import kotliquery.sessionOf -import no.nav.helse.januar -import no.nav.helse.modell.person.vedtaksperiode.Varsel -import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status.AKTIV -import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status.AVVIKLET -import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status.GODKJENT -import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status.INAKTIV -import no.nav.helse.modell.person.vedtaksperiode.Varsel.Status.VURDERT -import no.nav.helse.modell.vedtaksperiode.Generasjon -import no.nav.helse.modell.vedtaksperiode.Periode -import org.intellij.lang.annotations.Language -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertNotNull -import org.junit.jupiter.api.Assertions.assertNull -import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows -import java.time.LocalDateTime -import java.util.UUID - -internal class VarselDaoTest : DatabaseIntegrationTest() { - private val varselDao = VarselDao(dataSource) - private val definisjonDao = DefinisjonDao(dataSource) - - @Test - fun `lagre varsel`() { - definisjonDao.lagreDefinisjon(UUID.randomUUID(), "EN_KODE", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "EN_KODE", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - assertEquals(1, alleVarslerFor(VEDTAKSPERIODE).size) - } - - @Test - fun `lagre flere varsler`() { - definisjonDao.lagreDefinisjon(UUID.randomUUID(), "EN_KODE", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - definisjonDao.lagreDefinisjon( - UUID.randomUUID(), - "EN_ANNEN_KODE", - "EN_TITTEL", - "EN_FORKLARING", - "EN_HANDLING", - false, - LocalDateTime.now(), - ) - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "EN_KODE", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - varselDao.lagreVarsel(UUID.randomUUID(), "EN_ANNEN_KODE", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - assertEquals(2, alleVarslerFor(VEDTAKSPERIODE).size) - } - - @Test - fun `sjekk for aktivt varsel`() { - definisjonDao.lagreDefinisjon(UUID.randomUUID(), "KODE_33", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_33", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - assertEquals(AKTIV, varselDao.finnVarselstatus(VEDTAKSPERIODE, "KODE_33")) - } - - @Test - fun `sjekk for inaktivt varsel`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "KODE_24", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_24", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - varselDao.oppdaterStatus(VEDTAKSPERIODE, generasjonId, "KODE_24", INAKTIV, "EN_IDENT", definisjonId) - assertEquals(INAKTIV, varselDao.finnVarselstatus(VEDTAKSPERIODE, "KODE_24")) - } - - @Test - fun `Kan nullstille definisjon-ref og ident i oppdatering av varsel`() { - val generasjonId = UUID.randomUUID() - val varselId = UUID.randomUUID() - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "EN_KODE", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(varselId, "EN_KODE", LocalDateTime.now(), VEDTAKSPERIODE, generasjonId) - varselDao.oppdaterStatus(VEDTAKSPERIODE, generasjonId, "EN_KODE", INAKTIV, "ident", definisjonId) - - assertDefinisjonFor(varselId, forventetFinnes = true) - assertIdentFor(varselId, forventetFinnes = true) - - varselDao.oppdaterStatus(VEDTAKSPERIODE, generasjonId, "EN_KODE", AKTIV, null, null) - assertDefinisjonFor(varselId, forventetFinnes = false) - assertIdentFor(varselId, forventetFinnes = false) - } - - @Test - fun `endring av en varselstatus for en vedtaksperiode endrer ikke status for en annen`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "KODE_337", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val v1 = UUID.randomUUID() - val v2 = UUID.randomUUID() - val generasjonIdv1 = UUID.randomUUID() - val generasjonIdv2 = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonIdv1, - v1, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - generasjonDao.opprettFor( - generasjonIdv2, - v2, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_337", LocalDateTime.now(), v1, generasjonIdv1) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_337", LocalDateTime.now(), v2, generasjonIdv2) - varselDao.oppdaterStatus(v1, generasjonIdv1, "KODE_337", INAKTIV, "EN_IDENT", definisjonId) - assertEquals(INAKTIV, varselDao.finnVarselstatus(v1, "KODE_337")) - assertEquals(AKTIV, varselDao.finnVarselstatus(v2, "KODE_337")) - } - - @Test - fun `sletter varsel`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "KODE_EN", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - definisjonDao.lagreDefinisjon( - definisjonId, - "KODE_TO", - "EN_ANNEN_TITTEL", - "EN_ANNEN_FORKLARING", - "EN_ANNEN_HANDLING", - false, - LocalDateTime.now(), - ) - val v1 = UUID.randomUUID() - val generasjonIdv1 = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonIdv1, - v1, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_EN", LocalDateTime.now(), v1, generasjonIdv1) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_TO", LocalDateTime.now(), v1, generasjonIdv1) - varselDao.slettFor(v1, generasjonIdv1, "KODE_EN") - assertEquals(1, varselDao.varslerFor(generasjonIdv1).size) - } - - @Test - fun `avvikling av varsel`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "KODE_99", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - vedtaksperiodeId, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_99", LocalDateTime.now(), vedtaksperiodeId, generasjonId) - varselDao.avvikleVarsel("KODE_99", definisjonId) - assertEquals(AVVIKLET, varselDao.finnVarselstatus(vedtaksperiodeId, "KODE_99")) - } - - @Test - fun `avvikler ikke varsel hvis varsel ikke har status aktiv`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "KODE_42", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val vedtaksperiodeId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - vedtaksperiodeId, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "KODE_42", LocalDateTime.now(), vedtaksperiodeId, generasjonId) - - varselDao.oppdaterStatus(vedtaksperiodeId, generasjonId, "KODE_42", VURDERT, "EN_IDENT", definisjonId) - varselDao.avvikleVarsel("KODE_42", definisjonId) - assertEquals(VURDERT, varselDao.finnVarselstatus(vedtaksperiodeId, "KODE_42")) - varselDao.oppdaterStatus(vedtaksperiodeId, generasjonId, "KODE_42", GODKJENT, "EN_IDENT", definisjonId) - varselDao.avvikleVarsel("KODE_42", definisjonId) - assertEquals(GODKJENT, varselDao.finnVarselstatus(vedtaksperiodeId, "KODE_42")) - varselDao.oppdaterStatus(vedtaksperiodeId, generasjonId, "KODE_42", INAKTIV, "EN_IDENT", definisjonId) - varselDao.avvikleVarsel("KODE_42", definisjonId) - assertEquals(INAKTIV, varselDao.finnVarselstatus(vedtaksperiodeId, "KODE_42")) - } - - @Test - fun `kan ikke overskrive med samme status`() { - val definisjonId = UUID.randomUUID() - definisjonDao.lagreDefinisjon(definisjonId, "EN_KODE", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val v1 = UUID.randomUUID() - val generasjonIdv1 = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonIdv1, - v1, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(UUID.randomUUID(), "EN_KODE", LocalDateTime.now(), v1, generasjonIdv1) - varselDao.oppdaterStatus(v1, generasjonIdv1, "EN_KODE", VURDERT, "saksbehandler 1", definisjonId) - assertThrows { - varselDao.oppdaterStatus(v1, generasjonIdv1, "EN_KODE", VURDERT, "saksbehandler 2", definisjonId) - } - } - - @Test - fun `status gir null dersom vi ikke finner varsel`() { - assertNull(varselDao.finnVarselstatus(UUID.randomUUID(), "KODE_808")) - } - - @Test - fun `finner varsler for vedtaksperiode`() { - definisjonDao.lagreDefinisjon(UUID.randomUUID(), "EN_KODE", "EN_TITTEL", "EN_FORKLARING", "EN_HANDLING", false, LocalDateTime.now()) - val v1 = UUID.randomUUID() - val varselId = UUID.randomUUID() - val opprettet = LocalDateTime.now() - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - v1, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - varselDao.lagreVarsel(varselId, "EN_KODE", LocalDateTime.now(), v1, generasjonId) - assertEquals(listOf(Varsel(varselId, "EN_KODE", opprettet, v1)), alleVarslerFor(v1)) - } - - @Test - fun `flytter aktive varsler til neste generasjon`() { - val vedtaksperiodeId = UUID.randomUUID() - val generasjonIdv1 = UUID.randomUUID() - val generasjonIdv2 = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonIdv1, - vedtaksperiodeId, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - generasjonDao.opprettFor( - generasjonIdv2, - vedtaksperiodeId, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - val varselId = UUID.randomUUID() - varselDao.lagreVarsel(varselId, "EN_KODE", LocalDateTime.now(), vedtaksperiodeId, generasjonIdv1) - varselDao.oppdaterGenerasjon(varselId, generasjonIdv1, generasjonIdv2) - - assertVarslerFor(generasjonIdv1, 0) - assertVarslerFor(generasjonIdv2, 1) - } - - private fun assertDefinisjonFor( - varselId: UUID, - forventetFinnes: Boolean, - ) { - @Language("PostgreSQL") - val query = "SELECT definisjon_ref FROM selve_varsel WHERE unik_id = ?" - val definisjon = - sessionOf(dataSource).use { session -> - session.run(queryOf(query, varselId).map { it.longOrNull("definisjon_ref") }.asSingle) - } - if (!forventetFinnes) return assertNull(definisjon) - assertNotNull(definisjon) - } - - private fun assertIdentFor( - varselId: UUID, - forventetFinnes: Boolean, - ) { - @Language("PostgreSQL") - val query = "SELECT status_endret_ident FROM selve_varsel WHERE unik_id = ?" - val statusEndretIdent = - sessionOf(dataSource).use { session -> - session.run(queryOf(query, varselId).map { it.stringOrNull("status_endret_ident") }.asSingle) - } - if (!forventetFinnes) return assertNull(statusEndretIdent) - assertNotNull(statusEndretIdent) - } - - private fun alleVarslerFor(vedtaksperiodeId: UUID): List { - @Language("PostgreSQL") - val query = "SELECT unik_id,kode,opprettet FROM selve_varsel WHERE vedtaksperiode_id = ?;" - - sessionOf(dataSource).use { session -> - return session.run( - queryOf(query, vedtaksperiodeId).map { - Varsel( - it.uuid("unik_id"), - it.string("kode"), - it.localDateTime("opprettet"), - vedtaksperiodeId, - ) - }.asList, - ) - } - } - - private fun assertVarslerFor( - generasjonId: UUID, - forventetAntall: Int, - ) { - @Language("PostgreSQL") - val query = - """SELECT count(1) FROM selve_varsel WHERE generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = :generasjon_id)""" - - val antall = - sessionOf(dataSource).use { session -> - session.run( - queryOf(query, mapOf("generasjon_id" to generasjonId)).map { it.int(1) }.asSingle, - ) - } - - assertEquals(antall, forventetAntall) - } -} diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDaoTest.kt index b9e172d33..5a5652747 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDaoTest.kt @@ -1,407 +1,13 @@ package no.nav.helse.modell.vedtaksperiode import DatabaseIntegrationTest -import kotliquery.queryOf import kotliquery.sessionOf -import no.nav.helse.februar -import no.nav.helse.januar -import no.nav.helse.modell.person.vedtaksperiode.VarselDto -import no.nav.helse.modell.person.vedtaksperiode.VarselStatusDto -import no.nav.helse.modell.varsel.VarselDao -import org.intellij.lang.annotations.Language import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertFalse -import org.junit.jupiter.api.Assertions.assertNotNull -import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.Test -import org.junit.jupiter.api.assertThrows -import java.sql.SQLException -import java.time.LocalDate -import java.time.LocalDateTime -import java.time.temporal.ChronoUnit import java.util.UUID internal class GenerasjonDaoTest : DatabaseIntegrationTest() { - private val varselDao = VarselDao(dataSource) - - @Test - fun `lagre generasjon`() { - val id = UUID.randomUUID() - val vedtaksperiodeId = UUID.randomUUID() - val utbetalingId = UUID.randomUUID() - val spleisBehandlingId = UUID.randomUUID() - val varselId = UUID.randomUUID() - val varselOpprettet = LocalDateTime.now() - val varselstatus = VarselStatusDto.AKTIV - val tags = listOf("tag 1", "tag 2") - val generasjonDto = - nyGenerasjonDto( - id = id, - vedtaksperiodeId = vedtaksperiodeId, - utbetalingId = utbetalingId, - spleisBehandlingId = spleisBehandlingId, - tags = tags, - varsler = - listOf( - VarselDto(varselId, "RV_IM_1", varselOpprettet, vedtaksperiodeId, varselstatus), - ), - ) - generasjonDao.lagre(generasjonDto) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - checkNotNull(lagretGenerasjon) - assertEquals(id, lagretGenerasjon.id) - assertEquals(vedtaksperiodeId, lagretGenerasjon.vedtaksperiodeId) - assertEquals(1.januar, lagretGenerasjon.fom) - assertEquals(31.januar, lagretGenerasjon.tom) - assertEquals(1.januar, lagretGenerasjon.skjæringstidspunkt) - assertEquals(TilstandDto.VidereBehandlingAvklares, lagretGenerasjon.tilstand) - assertEquals(utbetalingId, lagretGenerasjon.utbetalingId) - assertEquals(spleisBehandlingId, lagretGenerasjon.spleisBehandlingId) - assertEquals(1, lagretGenerasjon.varsler.size) - val varsel = lagretGenerasjon.varsler.single() - assertEquals(varselId, varsel.id) - assertEquals("RV_IM_1", varsel.varselkode) - assertEquals(varselOpprettet.truncatedTo(ChronoUnit.MILLIS), varsel.opprettet.truncatedTo(ChronoUnit.MILLIS)) - assertEquals(varselstatus, varsel.status) - assertEquals(tags, lagretGenerasjon.tags) - assertEquals(vedtaksperiodeId, varsel.vedtaksperiodeId) - } - - @Test - fun `finn generasjoner`() { - val vedtaksperiodeId = UUID.randomUUID() - val generasjon1 = nyGenerasjonDto(vedtaksperiodeId) - val generasjon2 = nyGenerasjonDto(vedtaksperiodeId) - generasjonDao.lagre(generasjon1) - generasjonDao.lagre(generasjon2) - val generasjoner = - with(generasjonDao) { - sessionOf(dataSource).use { session -> - session.transaction { tx -> - tx.finnGenerasjoner(vedtaksperiodeId) - } - } - } - - assertEquals(2, generasjoner.size) - assertEquals(generasjon1, generasjoner[0]) - assertEquals(generasjon2, generasjoner[1]) - } - - @Test - fun `oppdatere generasjon`() { - val id = UUID.randomUUID() - val vedtaksperiodeId = UUID.randomUUID() - val nyUtbetalingId = UUID.randomUUID() - val generasjonDto = nyGenerasjonDto(vedtaksperiodeId, id) - generasjonDao.lagre(generasjonDto) - generasjonDao.lagre( - generasjonDto.copy( - utbetalingId = nyUtbetalingId, - fom = 2.januar, - tom = 30.januar, - skjæringstidspunkt = 2.januar, - tilstand = TilstandDto.VedtakFattet, - ), - ) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - assertNotNull(lagretGenerasjon) - assertEquals(id, lagretGenerasjon?.id) - assertEquals(vedtaksperiodeId, lagretGenerasjon?.vedtaksperiodeId) - assertEquals(2.januar, lagretGenerasjon?.fom) - assertEquals(30.januar, lagretGenerasjon?.tom) - assertEquals(2.januar, lagretGenerasjon?.skjæringstidspunkt) - assertEquals(TilstandDto.VedtakFattet, lagretGenerasjon?.tilstand) - assertEquals(nyUtbetalingId, lagretGenerasjon?.utbetalingId) - } - - @Test - fun `legg til varsel`() { - val id = UUID.randomUUID() - val vedtaksperiodeId = UUID.randomUUID() - val varselId = UUID.randomUUID() - val varselOpprettet = LocalDateTime.now() - val varselstatus = VarselStatusDto.AKTIV - val generasjonDto = nyGenerasjonDto(vedtaksperiodeId, id) - generasjonDao.lagre(generasjonDto) - generasjonDao.lagre( - generasjonDto.copy(varsler = listOf(VarselDto(varselId, "RV_IM_1", varselOpprettet, vedtaksperiodeId, varselstatus))), - ) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - - assertNotNull(lagretGenerasjon) - assertEquals(1, lagretGenerasjon?.varsler?.size) - } - - @Test - fun `oppdatere varsel`() { - val vedtaksperiodeId = UUID.randomUUID() - val varselId = UUID.randomUUID() - val varselOpprettet = LocalDateTime.now() - val generasjonDto = - nyGenerasjonDto( - vedtaksperiodeId = vedtaksperiodeId, - varsler = listOf(VarselDto(varselId, "RV_IM_1", varselOpprettet, vedtaksperiodeId, VarselStatusDto.AKTIV)), - ) - generasjonDao.lagre(generasjonDto) - generasjonDao.lagre( - generasjonDto.copy( - varsler = listOf(VarselDto(varselId, "RV_IM_1", varselOpprettet, vedtaksperiodeId, VarselStatusDto.VURDERT)), - ), - ) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - - assertNotNull(lagretGenerasjon) - assertEquals(1, lagretGenerasjon?.varsler?.size) - val varsel = lagretGenerasjon?.varsler?.single() - assertEquals(VarselStatusDto.VURDERT, varsel?.status) - } - - @Test - fun `fjerne varsel`() { - val id = UUID.randomUUID() - val vedtaksperiodeId = UUID.randomUUID() - val varselIdSomIkkeBlirSlettet = UUID.randomUUID() - val varselOpprettetSomIkkeBlirSlettet = LocalDateTime.now() - val generasjonDto = - nyGenerasjonDto( - vedtaksperiodeId = vedtaksperiodeId, - id = id, - varsler = - listOf( - VarselDto( - varselIdSomIkkeBlirSlettet, - "RV_IM_1", - varselOpprettetSomIkkeBlirSlettet, - vedtaksperiodeId, - VarselStatusDto.AKTIV, - ), - VarselDto(UUID.randomUUID(), "RV_IM_2", LocalDateTime.now(), vedtaksperiodeId, VarselStatusDto.AKTIV), - ), - ) - generasjonDao.lagre(generasjonDto) - generasjonDao.lagre( - generasjonDto.copy( - varsler = - listOf( - VarselDto( - varselIdSomIkkeBlirSlettet, - "RV_IM_1", - varselOpprettetSomIkkeBlirSlettet, - vedtaksperiodeId, - VarselStatusDto.AKTIV, - ), - ), - ), - ) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - - assertNotNull(lagretGenerasjon) - assertEquals(1, lagretGenerasjon?.varsler?.size) - } - - @Test - fun `fjerne varsel slik at det ikke er noen varsler igjen på generasjonen`() { - val vedtaksperiodeId = UUID.randomUUID() - val varselId = UUID.randomUUID() - val varselOpprettet = LocalDateTime.now() - val generasjonDto = - nyGenerasjonDto( - vedtaksperiodeId = vedtaksperiodeId, - varsler = listOf(VarselDto(varselId, "RV_IM_1", varselOpprettet, vedtaksperiodeId, VarselStatusDto.AKTIV)), - ) - generasjonDao.lagre(generasjonDto) - generasjonDao.lagre(generasjonDto.copy(varsler = emptyList())) - val lagretGenerasjon = generasjonDao.finnGjeldendeGenerasjon(vedtaksperiodeId) - - assertNotNull(lagretGenerasjon) - assertEquals(0, lagretGenerasjon?.varsler?.size) - } - - @Test - fun `oppretter generasjon for vedtaksperiode`() { - val generasjonId = UUID.randomUUID() - val generasjon = - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - - val forventetGenerasjon = Generasjon(generasjonId, VEDTAKSPERIODE, 1.januar, 31.januar, 1.januar) - assertEquals(forventetGenerasjon, generasjon) - } - - @Test - fun `oppretter generasjon for vedtaksperiode med skjæringstidspunkt og periode`() { - val generasjonId = UUID.randomUUID() - val periode = Periode(1.januar, 5.januar) - val generasjon = - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - periode, - Generasjon.VidereBehandlingAvklares, - null, - ) - - val forventetGenerasjon = Generasjon(generasjonId, VEDTAKSPERIODE, 1.januar, 5.januar, 1.januar) - assertEquals(forventetGenerasjon, generasjon) - } - - @Test - fun `kan bytte tilstand for generasjon`() { - val vedtaksperiodeEndretId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - vedtaksperiodeEndretId, - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - generasjonDao.oppdaterTilstandFor(generasjonId, Generasjon.VedtakFattet.navn(), UUID.randomUUID()) - - assertTilstand(VEDTAKSPERIODE, Generasjon.VedtakFattet) - } - - @Test - fun `slår opp tags på ikke-eksisterende behandling`() { - val tulleId = UUID.randomUUID() - val tags = generasjonDao.finnTagsFor(tulleId) - assertNull(tags) - } - - @Test - fun `behandling uten tags gir tom liste`() { - val vedtaksperiodeId = UUID.randomUUID() - val spleisBehandlingId = UUID.randomUUID() - val generasjon1 = nyGenerasjonDto(vedtaksperiodeId = vedtaksperiodeId, spleisBehandlingId = spleisBehandlingId) - generasjonDao.lagre(generasjon1) - val tags = generasjonDao.finnTagsFor(spleisBehandlingId) - assertTrue(tags != null && tags.isEmpty()) - } - @Test - fun `kaster feil dersom spørring gir mer enn et treff`() { - val vedtaksperiodeId = UUID.randomUUID() - val spleisBehandlingId = UUID.randomUUID() - val generasjon1 = nyGenerasjonDto(vedtaksperiodeId = vedtaksperiodeId, spleisBehandlingId = spleisBehandlingId) - val generasjon2 = nyGenerasjonDto(vedtaksperiodeId = vedtaksperiodeId, spleisBehandlingId = spleisBehandlingId) - generasjonDao.lagre(generasjon1) - generasjonDao.lagre(generasjon2) - assertThrows { generasjonDao.finnTagsFor(spleisBehandlingId) } - } - - @Test - fun `gir false tilbake dersom vi ikke finner noen generasjon`() { - val funnet = generasjonDao.harGenerasjonFor(VEDTAKSPERIODE) - assertFalse(funnet) - } - - @Test - fun `har generasjon`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - val funnet = generasjonDao.harGenerasjonFor(VEDTAKSPERIODE) - assertTrue(funnet) - } - - @Test - fun `finn skjæringstidspunkt`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - val skjæringstidspunkt = generasjonDao.finnSkjæringstidspunktFor(VEDTAKSPERIODE) - assertEquals(1.januar, skjæringstidspunkt) - } - - @Test - fun `finn skjæringstidspunkt for siste generasjon`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VedtakFattet, - null, - ) - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - UUID.randomUUID(), - 2.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - - val skjæringstidspunkt = generasjonDao.finnSkjæringstidspunktFor(VEDTAKSPERIODE) - assertEquals(2.januar, skjæringstidspunkt) - } - - @Test - fun `generasjon hentes opp sammen med varsler`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - val varselId = UUID.randomUUID() - val varselOpprettet = LocalDateTime.now() - val generasjonId = generasjonIdFor(VEDTAKSPERIODE) - varselDao.lagreVarsel(varselId, "EN_KODE", varselOpprettet, VEDTAKSPERIODE, generasjonId) - assertVarsler(generasjonId, "EN_KODE") - } - - @Test - fun `finner liste av unike vedtaksperiodeIder med fnr og skjæringstidspunkt`() { - val vedtaksperiodeId1 = UUID.randomUUID() - val vedtaksperiodeId2 = UUID.randomUUID() - val generasjonId1 = UUID.randomUUID() - val generasjonId2 = UUID.randomUUID() - val generasjonId3 = UUID.randomUUID() - - opprettPerson() - opprettArbeidsgiver() - opprettVedtaksperiode(vedtaksperiodeId1) - opprettGenerasjon(vedtaksperiodeId1, generasjonId1) - opprettVedtaksperiode(vedtaksperiodeId2) - opprettGenerasjon(vedtaksperiodeId2, generasjonId2) - opprettGenerasjon(vedtaksperiodeId2, generasjonId3) - - val vedtaksperiodeIder = generasjonDao.finnVedtaksperiodeIderFor(FNR, 1.januar) - assertEquals(2, vedtaksperiodeIder.size) - assertTrue(vedtaksperiodeIder.containsAll(setOf(vedtaksperiodeId1, vedtaksperiodeId2))) - } - @Test fun `finner liste av unike vedtaksperiodeIder med fnr`() { val vedtaksperiodeId1 = UUID.randomUUID() @@ -412,9 +18,9 @@ internal class GenerasjonDaoTest : DatabaseIntegrationTest() { opprettPerson() opprettArbeidsgiver() - opprettVedtaksperiode(vedtaksperiodeId1) + opprettVedtaksperiode(vedtaksperiodeId = vedtaksperiodeId1) opprettGenerasjon(vedtaksperiodeId1, generasjonId1) - opprettVedtaksperiode(vedtaksperiodeId2) + opprettVedtaksperiode(vedtaksperiodeId = vedtaksperiodeId2) opprettGenerasjon(vedtaksperiodeId2, generasjonId2) opprettGenerasjon(vedtaksperiodeId2, generasjonId3) @@ -429,203 +35,4 @@ internal class GenerasjonDaoTest : DatabaseIntegrationTest() { assertEquals(2, vedtaksperiodeIder.size) assertTrue(vedtaksperiodeIder.containsAll(setOf(vedtaksperiodeId1, vedtaksperiodeId2))) } - - @Test - fun `finner ikke vedtaksperiodeIder for forkastede perioder`() { - val vedtaksperiodeId = UUID.randomUUID() - nyPerson() - val generasjonId2 = UUID.randomUUID() - - opprettVedtaksperiode(vedtaksperiodeId, forkastet = true) - opprettGenerasjon(vedtaksperiodeId, generasjonId2) - val vedtaksperiodeIder = generasjonDao.finnVedtaksperiodeIderFor(FNR, 1.januar) - assertEquals(1, vedtaksperiodeIder.size) - assertTrue(vedtaksperiodeIder.contains(VEDTAKSPERIODE)) - } - - @Test - fun `Lager innslag i opprinnelig_soknadsdato`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - - assertEquals(finnTidligsteGenerasjonOpprettetTidspunkt(VEDTAKSPERIODE), finnSøknadMottatt(VEDTAKSPERIODE)) - } - - @Test - fun `Lager ikke innslag i opprinnelig_soknadsdato for ettergølgende generasjoner`() { - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VedtakFattet, - null, - ) - val opprinneligSøknadsdato = finnSøknadMottatt(VEDTAKSPERIODE) - generasjonDao.opprettFor( - UUID.randomUUID(), - VEDTAKSPERIODE, - UUID.randomUUID(), - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - - assertEquals(opprinneligSøknadsdato, finnSøknadMottatt(VEDTAKSPERIODE)) - } - - @Test - fun `Finner første generasjons VedtakFattet tidspunkt`() { - val vedtaksperiodeEndretId = UUID.randomUUID() - val generasjonId = UUID.randomUUID() - generasjonDao.opprettFor( - generasjonId, - VEDTAKSPERIODE, - vedtaksperiodeEndretId, - 1.januar, - Periode(1.januar, 31.januar), - Generasjon.VidereBehandlingAvklares, - null, - ) - generasjonDao.oppdaterTilstandFor(generasjonId, Generasjon.VedtakFattet.navn(), UUID.randomUUID()) - - assertNotNull(generasjonDao.førsteGenerasjonVedtakFattetTidspunkt(VEDTAKSPERIODE)) - } - - private fun Pair.tilPeriode() = Periode(first, second) - - @Test - fun `Finner første kjente dato for person`() { - opprettPerson() - opprettArbeidsgiver() - val førstePeriode = 1.januar to 5.januar - val vedtaksperiodeId1 = UUID.randomUUID() - opprettVedtaksperiode(vedtaksperiodeId1, fom = førstePeriode.first, tom = førstePeriode.second) - generasjonDao.opprettFor( - UUID.randomUUID(), - vedtaksperiodeId1, - UUID.randomUUID(), - førstePeriode.first, - førstePeriode.tilPeriode(), - Generasjon.VedtakFattet, - null, - ) - - val vedtaksperiodeId2 = UUID.randomUUID() - val senerePeriode = 10.februar(2022) to 20.februar(2022) - opprettVedtaksperiode(vedtaksperiodeId2, fom = senerePeriode.first, tom = senerePeriode.second) - generasjonDao.opprettFor( - UUID.randomUUID(), - vedtaksperiodeId2, - UUID.randomUUID(), - senerePeriode.first, - senerePeriode.tilPeriode(), - Generasjon.VedtakFattet, - null, - ) - - assertEquals(1.januar, generasjonDao.førsteKjenteDag(FNR)) - } - - private fun nyGenerasjonDto( - vedtaksperiodeId: UUID = UUID.randomUUID(), - id: UUID = UUID.randomUUID(), - utbetalingId: UUID? = UUID.randomUUID(), - spleisBehandlingId: UUID? = UUID.randomUUID(), - fom: LocalDate = 1.januar, - tom: LocalDate = 31.januar, - skjæringstidspunkt: LocalDate = 1.januar, - tilstand: TilstandDto = TilstandDto.VidereBehandlingAvklares, - tags: List = emptyList(), - varsler: List = emptyList(), - ): GenerasjonDto { - return GenerasjonDto( - id = id, - vedtaksperiodeId = vedtaksperiodeId, - utbetalingId = utbetalingId, - spleisBehandlingId = spleisBehandlingId, - skjæringstidspunkt = skjæringstidspunkt, - fom = fom, - tom = tom, - tilstand = tilstand, - tags = tags, - varsler = varsler, - ) - } - - private fun assertVarsler( - generasjonId: UUID, - vararg forventedeVarselkoder: String, - ) { - @Language("PostgreSQL") - val query = - "SELECT kode FROM selve_varsel WHERE generasjon_ref = (SELECT id FROM selve_vedtaksperiode_generasjon WHERE unik_id = ?)" - - val varselkoder = - sessionOf(dataSource).use { session -> - session.run(queryOf(query, generasjonId).map { it.string("kode") }.asList).toSet() - } - assertEquals(forventedeVarselkoder.toSet(), varselkoder) - } - - private fun generasjonIdFor(vedtaksperiodeId: UUID): UUID { - @Language("PostgreSQL") - val query = - "SELECT unik_id FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ? ORDER BY id" - - return sessionOf(dataSource).use { session -> - session.run(queryOf(query, vedtaksperiodeId).map { it.uuid("unik_id") }.asList).single() - } - } - - private fun assertTilstand( - vedtaksperiodeId: UUID, - forventetTilstand: Generasjon.Tilstand, - ) { - val tilstand = - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = - "SELECT tilstand FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ?;" - - session.run( - queryOf(query, vedtaksperiodeId).map { - it.string("tilstand") - }.asSingle, - ) - } - - assertEquals(forventetTilstand.navn(), tilstand) - } - - private fun finnSøknadMottatt(vedtaksperiodeId: UUID) = - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = "SELECT soknad_mottatt FROM opprinnelig_soknadsdato WHERE vedtaksperiode_id = ?" - session.run( - queryOf(query, vedtaksperiodeId).map { - it.localDateTimeOrNull("soknad_mottatt") - }.asSingle, - ) - } - - private fun finnTidligsteGenerasjonOpprettetTidspunkt(vedtaksperiodeId: UUID) = - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = "SELECT min(opprettet_tidspunkt) as opprettet_tidspunkt FROM selve_vedtaksperiode_generasjon WHERE vedtaksperiode_id = ? GROUP BY vedtaksperiode_id" - session.run( - queryOf(query, vedtaksperiodeId).map { - it.localDateTimeOrNull("opprettet_tidspunkt") - }.asSingle, - ) - } } diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTest.kt index 72b4580a2..824b9c17b 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTest.kt @@ -172,7 +172,7 @@ internal class GenerasjonTest { fun `Generasjon kan motta ny utbetalingId`() { val generasjon = generasjon() val utbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) } @Test @@ -180,9 +180,9 @@ internal class GenerasjonTest { val generasjon = generasjon() val gammelUtbetalingId = UUID.randomUUID() val nyUtbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), gammelUtbetalingId) + generasjon.håndterNyUtbetaling(gammelUtbetalingId) generasjon.håndterForkastetUtbetaling(gammelUtbetalingId) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), nyUtbetalingId) + generasjon.håndterNyUtbetaling(nyUtbetalingId) assertEquals(nyUtbetalingId, generasjon.toDto().utbetalingId) } @@ -211,9 +211,9 @@ internal class GenerasjonTest { val generasjon = generasjon() val gammelUtbetalingId = UUID.randomUUID() val nyUtbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), gammelUtbetalingId) + generasjon.håndterNyUtbetaling(gammelUtbetalingId) generasjon.håndterVedtakFattet(UUID.randomUUID()) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), nyUtbetalingId) + generasjon.håndterNyUtbetaling(nyUtbetalingId) assertEquals(gammelUtbetalingId, generasjon.toDto().utbetalingId) } @@ -224,10 +224,10 @@ internal class GenerasjonTest { val nyUtbetalingId = UUID.randomUUID() val generasjon = generasjon() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) generasjon.håndterVedtakFattet(UUID.randomUUID()) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), nyUtbetalingId) + generasjon.håndterNyUtbetaling(nyUtbetalingId) generasjon.assertUtbetalingId(utbetalingId) } @@ -235,7 +235,7 @@ internal class GenerasjonTest { fun `kan fjerne utbetalingId fra ubehandlet generasjon`() { val generasjon = generasjon() val utbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) generasjon.assertUtbetalingId(utbetalingId) generasjon.håndterForkastetUtbetaling(utbetalingId) generasjon.assertUtbetalingId(null) @@ -245,7 +245,7 @@ internal class GenerasjonTest { fun `kan ikke fjerne utbetalingId fra ferdig behandlet generasjon`() { val generasjon = generasjon() val utbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) generasjon.håndterVedtakFattet(UUID.randomUUID()) generasjon.håndterForkastetUtbetaling(utbetalingId) generasjon.assertUtbetalingId(utbetalingId) @@ -394,11 +394,11 @@ internal class GenerasjonTest { val spleisBehandlingId = UUID.randomUUID() val generasjon1 = generasjon(generasjonId, vedtaksperiodeId) val utbetalingId = UUID.randomUUID() - generasjon1.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon1.håndterNyUtbetaling(utbetalingId) generasjon1.oppdaterBehandlingsinformasjon(emptyList(), spleisBehandlingId, utbetalingId) generasjon1.håndterVedtakFattet(UUID.randomUUID()) val generasjon2 = generasjon(generasjonId, vedtaksperiodeId) - generasjon2.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon2.håndterNyUtbetaling(utbetalingId) generasjon2.oppdaterBehandlingsinformasjon(emptyList(), spleisBehandlingId, utbetalingId) generasjon2.håndterVedtakFattet(UUID.randomUUID()) assertEquals(generasjon1, generasjon2) @@ -434,12 +434,12 @@ internal class GenerasjonTest { val generasjon1 = generasjon(generasjonId, vedtaksperiodeId) val spleisBehandlingId = UUID.randomUUID() val utbetalingId1 = UUID.randomUUID() - generasjon1.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId1) + generasjon1.håndterNyUtbetaling(utbetalingId1) generasjon1.oppdaterBehandlingsinformasjon(listOf("hei"), spleisBehandlingId, utbetalingId1) val generasjon2 = generasjon(generasjonId, vedtaksperiodeId) val spleisBehandlingId2 = UUID.randomUUID() val utbetalingId2 = UUID.randomUUID() - generasjon2.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId2) + generasjon2.håndterNyUtbetaling(utbetalingId2) generasjon2.oppdaterBehandlingsinformasjon(listOf("hallo"), spleisBehandlingId2, utbetalingId2) assertNotEquals(generasjon1, generasjon2) assertNotEquals(generasjon1.hashCode(), generasjon2.hashCode()) @@ -450,9 +450,9 @@ internal class GenerasjonTest { val generasjonId = UUID.randomUUID() val vedtaksperiodeId = UUID.randomUUID() val generasjon1 = generasjon(generasjonId, vedtaksperiodeId) - generasjon1.håndterNyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + generasjon1.håndterNyUtbetaling(UUID.randomUUID()) val generasjon2 = generasjon(generasjonId, vedtaksperiodeId) - generasjon2.håndterNyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + generasjon2.håndterNyUtbetaling(UUID.randomUUID()) assertNotEquals(generasjon1, generasjon2) assertNotEquals(generasjon1.hashCode(), generasjon2.hashCode()) } @@ -462,7 +462,7 @@ internal class GenerasjonTest { val generasjonId = UUID.randomUUID() val vedtaksperiodeId = UUID.randomUUID() val generasjon1 = generasjon(generasjonId, vedtaksperiodeId) - generasjon1.håndterNyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + generasjon1.håndterNyUtbetaling(UUID.randomUUID()) val generasjon2 = generasjon(generasjonId, vedtaksperiodeId) assertNotEquals(generasjon1, generasjon2) assertNotEquals(generasjon1.hashCode(), generasjon2.hashCode()) @@ -509,7 +509,7 @@ internal class GenerasjonTest { val utbetalingId = UUID.randomUUID() val spleisBehandlingId = UUID.randomUUID() val generasjon = Generasjon(generasjonId, vedtaksperiodeId, fom, tom, skjæringstidspunkt) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) val tags = listOf("tag 1") generasjon.oppdaterBehandlingsinformasjon(tags, spleisBehandlingId, utbetalingId) diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTilstandTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTilstandTest.kt index c21d47c83..eabed939b 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTilstandTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonTilstandTest.kt @@ -18,7 +18,7 @@ internal class GenerasjonTilstandTest { val generasjon = generasjon(generasjonId, UUID.randomUUID()) val utbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) generasjon.assertTilstand(TilstandDto.KlarTilBehandling) generasjon.håndterForkastetUtbetaling(utbetalingId) generasjon.assertTilstand(TilstandDto.VidereBehandlingAvklares) @@ -49,7 +49,7 @@ internal class GenerasjonTilstandTest { val generasjonId = UUID.randomUUID() val generasjon = generasjon(generasjonId, UUID.randomUUID()) generasjon.assertTilstand(TilstandDto.VidereBehandlingAvklares) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + generasjon.håndterNyUtbetaling(UUID.randomUUID()) generasjon.assertTilstand(TilstandDto.KlarTilBehandling) } @@ -58,7 +58,7 @@ internal class GenerasjonTilstandTest { val generasjonId = UUID.randomUUID() val generasjon = generasjon(generasjonId, UUID.randomUUID()) generasjon.assertTilstand(TilstandDto.VidereBehandlingAvklares) - generasjon.håndterNyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + generasjon.håndterNyUtbetaling(UUID.randomUUID()) generasjon.assertTilstand(TilstandDto.KlarTilBehandling) generasjon.håndterVedtakFattet(UUID.randomUUID()) generasjon.assertTilstand(TilstandDto.VedtakFattet) @@ -71,7 +71,7 @@ internal class GenerasjonTilstandTest { val generasjon = generasjon(generasjonId, vedtaksperiodeId) val utbetalingId = UUID.randomUUID() - generasjon.håndterNyUtbetaling(UUID.randomUUID(), utbetalingId) + generasjon.håndterNyUtbetaling(utbetalingId) generasjon.assertTilstand(TilstandDto.KlarTilBehandling) generasjon.håndterVedtakFattet(UUID.randomUUID()) diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeTest.kt index 9a3412241..a7d8a3cb3 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/vedtaksperiode/VedtaksperiodeTest.kt @@ -61,7 +61,7 @@ class VedtaksperiodeTest { val vedtaksperiodeId = UUID.randomUUID() val spleisBehandlingId = UUID.randomUUID() val vedtaksperiode = nyVedtaksperiode(vedtaksperiodeId, spleisBehandlingId) - vedtaksperiode.nyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + vedtaksperiode.nyUtbetaling(UUID.randomUUID()) vedtaksperiode.vedtakFattet(UUID.randomUUID(), spleisBehandlingId) vedtaksperiode.nySpleisBehandling(nySpleisBehandling(vedtaksperiodeId)) val generasjoner = vedtaksperiode.toDto().generasjoner @@ -98,7 +98,7 @@ class VedtaksperiodeTest { fun `oppdater gjeldende generasjon dersom gjeldende generasjon er klar til behandling ved godkjenningsbehov`() { val vedtaksperiodeId = UUID.randomUUID() val vedtaksperiode = nyVedtaksperiode(vedtaksperiodeId) - vedtaksperiode.nyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + vedtaksperiode.nyUtbetaling(UUID.randomUUID()) vedtaksperiode.nyttGodkjenningsbehov( listOf(SpleisVedtaksperiode(vedtaksperiodeId, UUID.randomUUID(), 1.februar, 28.februar, 1.februar)), ) @@ -128,7 +128,7 @@ class VedtaksperiodeTest { val vedtaksperiodeId = UUID.randomUUID() val spleisBehandlingId = UUID.randomUUID() val vedtaksperiode = nyVedtaksperiode(vedtaksperiodeId, spleisBehandlingId) - vedtaksperiode.nyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + vedtaksperiode.nyUtbetaling(UUID.randomUUID()) vedtaksperiode.vedtakFattet(UUID.randomUUID(), spleisBehandlingId) vedtaksperiode.nyttGodkjenningsbehov( listOf(SpleisVedtaksperiode(vedtaksperiodeId, UUID.randomUUID(), 1.januar, 31.januar, 1.januar)), @@ -142,7 +142,7 @@ class VedtaksperiodeTest { val vedtaksperiodeId = UUID.randomUUID() val spleisBehandlingId = UUID.randomUUID() val vedtaksperiode = nyVedtaksperiode(vedtaksperiodeId, spleisBehandlingId) - vedtaksperiode.nyUtbetaling(UUID.randomUUID(), UUID.randomUUID()) + vedtaksperiode.nyUtbetaling(UUID.randomUUID()) vedtaksperiode.vedtakFattet(UUID.randomUUID(), UUID.randomUUID()) vedtaksperiode.nyttGodkjenningsbehov( listOf(SpleisVedtaksperiode(vedtaksperiodeId, spleisBehandlingId, 1.januar, 31.januar, 1.januar)),