POC Cucumber

pom.xml

@@ -37,7 +37,7 @@
         <prosessering.version>1.20211125150647_a7c6f64</prosessering.version>
         <start-class>no.nav.familie.ef.sak.ApplicationKt</start-class>
         <kontrakter.version>2.0_20220222213922_64795e8</kontrakter.version>
-
+        <cucumber.version>7.2.3</cucumber.version>
 
         <!--suppress UnresolvedMavenProperty  Ligger som secret i github-->
         <sonar.projectKey>${SONAR_PROJECTKEY}</sonar.projectKey>
@@ -222,6 +222,25 @@
             <version>${unleash.version}</version>
         </dependency>
 
+        <dependency>
+            <groupId>io.cucumber</groupId>
+            <artifactId>cucumber-java</artifactId>
+            <version>${cucumber.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>io.cucumber</groupId>
+            <artifactId>cucumber-junit-platform-engine</artifactId>
+            <version>${cucumber.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-suite</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <profiles>
@@ -306,7 +325,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
-                <version>2.22.2</version>
+                <version>3.0.0-M5</version>
             </plugin>
         </plugins>
     </build>

src/test/kotlin/no/nav/familie/ef/sak/RunCucumberTest.kt

@@ -0,0 +1,14 @@
+package no.nav.familie.ef.sak
+
+import io.cucumber.core.options.Constants.PLUGIN_PROPERTY_NAME
+import org.junit.platform.suite.api.ConfigurationParameter;
+import org.junit.platform.suite.api.IncludeEngines;
+import org.junit.platform.suite.api.SelectClasspathResource;
+import org.junit.platform.suite.api.Suite;
+
+
+@Suite
+@IncludeEngines("cucumber")
+@SelectClasspathResource("no/nav/familie/ef/sak")
+@ConfigurationParameter(key = PLUGIN_PROPERTY_NAME, value = "pretty")
+class RunCucumberTest

src/test/kotlin/no/nav/familie/ef/sak/cucumber/domeneparser/BasisDomeneParser.kt

@@ -0,0 +1,141 @@
+package no.nav.familie.ef.sak.no.nav.familie.ef.sak.cucumber.domeneparser
+
+import io.cucumber.datatable.DataTable
+import no.nav.familie.ef.sak.vedtak.EndringType
+import no.nav.familie.ef.sak.vedtak.dto.ResultatType
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+val norskDatoFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy")
+val isoDatoFormatter = DateTimeFormatter.ISO_LOCAL_DATE
+
+fun parseDato(domenebegrep: Domenenøkkel, rad: Map<String, String>): LocalDate {
+    return parseDato(domenebegrep.nøkkel(), rad)
+}
+
+fun parseValgfriDato(domenebegrep: Domenenøkkel, rad: Map<String, String?>): LocalDate? {
+    return parseValgfriDato(domenebegrep.nøkkel(), rad)
+}
+
+fun parseString(domenebegrep: Domenenøkkel, rad: Map<String, String>): String {
+    return verdi(domenebegrep.nøkkel(), rad)
+}
+
+fun parseValgfriString(domenebegrep: Domenenøkkel, rad: Map<String, String>): String? {
+    return valgfriVerdi(domenebegrep.nøkkel(), rad)
+}
+
+fun parseBooleanMedBooleanVerdi(domenebegrep: Domenenøkkel, rad: Map<String, String>): Boolean {
+    val verdi = verdi(domenebegrep.nøkkel(), rad)
+
+    return when (verdi) {
+        "true" -> true
+        else -> false
+    }
+}
+
+fun parseBoolean(domenebegrep: Domenenøkkel, rad: Map<String, String>): Boolean {
+    val verdi = verdi(domenebegrep.nøkkel(), rad)
+
+    return when (verdi) {
+        "Ja" -> true
+        else -> false
+    }
+}
+
+fun parseValgfriBoolean(domenebegrep: String, rad: Map<String, String?>): Boolean? {
+
+    if (rad.get(domenebegrep) == null || rad.get(domenebegrep) == "") {
+        return null
+    }
+
+    return when (rad.get(domenebegrep)) {
+        "Ja" -> true
+        "Nei" -> false
+        else -> null
+    }
+}
+
+fun parseDato(domenebegrep: String, rad: Map<String, String>): LocalDate {
+    val dato = rad.get(domenebegrep)!!
+
+    return if (dato.contains(".")) {
+        LocalDate.parse(dato, norskDatoFormatter)
+    } else {
+        LocalDate.parse(dato, isoDatoFormatter)
+    }
+}
+
+fun parseValgfriDato(domenebegrep: String, rad: Map<String, String?>): LocalDate? {
+    if (rad.get(domenebegrep) == null || rad.get(domenebegrep) == "") {
+        return null
+    }
+    val dato = rad.get(domenebegrep)!!
+
+    return if (dato.contains(".")) {
+        LocalDate.parse(dato, norskDatoFormatter)
+    } else {
+        LocalDate.parse(dato, isoDatoFormatter)
+    }
+}
+
+fun verdi(nøkkel: String, rad: Map<String, String>): String {
+    val verdi = rad.get(nøkkel)
+
+    if (verdi == null || verdi == "") {
+        throw java.lang.RuntimeException("Fant ingen verdi for $nøkkel")
+    }
+
+    return verdi
+}
+
+fun valgfriVerdi(nøkkel: String, rad: Map<String, String>): String? {
+    val verdi = rad.get(nøkkel)
+
+    return verdi
+}
+
+fun parseInt(domenebegrep: Domenenøkkel, rad: Map<String, String>): Int {
+    val verdi = verdi(domenebegrep.nøkkel(), rad)
+
+    return Integer.parseInt(verdi)
+}
+
+fun parseDouble(domenebegrep: Domenenøkkel, rad: Map<String, String>): Double {
+    val verdi = verdi(domenebegrep.nøkkel(), rad)
+    return verdi.toDouble()
+}
+
+fun parseValgfriDouble(domenebegrep: Domenenøkkel, rad: Map<String, String>): Double? {
+    return valgfriVerdi(domenebegrep.nøkkel(), rad)?.toDouble() ?: return null
+}
+
+fun parseValgfriInt(domenebegrep: Domenenøkkel, rad: Map<String, String>): Int? {
+    val verdi = valgfriVerdi(domenebegrep.nøkkel(), rad)
+    if (verdi == null) {
+        return null
+    }
+
+    return parseInt(domenebegrep, rad)
+}
+
+fun parseResultatType(rad: Map<String, String>): ResultatType {
+    val verdi = verdi(VedtakDomenebegrep.RESULTAT_TYPE.nøkkel, rad)
+    return ResultatType.valueOf(verdi)
+}
+
+fun parseEndringType(rad: Map<String, String>): EndringType? {
+    val verdi = valgfriVerdi(VedtakDomenebegrep.ENDRING_TYPE.nøkkel, rad) ?: return null
+    return EndringType.valueOf(verdi)
+}
+
+
+fun <T> mapDataTable(dataTable: DataTable, radMapper: RadMapper<T>): List<T> {
+    return dataTable.asMaps().map { radMapper.mapRad(it) }
+}
+
+
+interface RadMapper<T> {
+
+    fun mapRad(rad: Map<String, String>): T
+}

src/test/kotlin/no/nav/familie/ef/sak/cucumber/domeneparser/DomeneParser.kt

@@ -0,0 +1,11 @@
+package no.nav.familie.ef.sak.no.nav.familie.ef.sak.cucumber.domeneparser
+
+enum class Domenebegrep(val nøkkel: String) : Domenenøkkel {
+    BEHANDLING_ID("BehandlingId"),
+    FRA_OG_MED_DATO("Fra og med dato"),
+    TIL_OG_MED_DATO("Til og med dato");
+
+    override fun nøkkel(): String {
+        return nøkkel
+    }
+}

src/test/kotlin/no/nav/familie/ef/sak/cucumber/domeneparser/Domenenøkkel.kt

@@ -0,0 +1,6 @@
+package no.nav.familie.ef.sak.no.nav.familie.ef.sak.cucumber.domeneparser
+
+interface Domenenøkkel {
+
+    fun nøkkel(): String
+}

src/test/kotlin/no/nav/familie/ef/sak/cucumber/domeneparser/VedtakDomeneParser.kt

@@ -0,0 +1,143 @@
+package no.nav.familie.ef.sak.no.nav.familie.ef.sak.cucumber.domeneparser
+
+import io.cucumber.datatable.DataTable
+import no.nav.familie.ef.sak.tilkjentytelse.domain.AndelTilkjentYtelse
+import no.nav.familie.ef.sak.tilkjentytelse.domain.TilkjentYtelse
+import no.nav.familie.ef.sak.tilkjentytelse.domain.TilkjentYtelseType
+import no.nav.familie.ef.sak.vedtak.HistorikkEndring
+import no.nav.familie.ef.sak.vedtak.domain.AktivitetType
+import no.nav.familie.ef.sak.vedtak.domain.PeriodeWrapper
+import no.nav.familie.ef.sak.vedtak.domain.Vedtak
+import no.nav.familie.ef.sak.vedtak.domain.Vedtaksperiode
+import no.nav.familie.ef.sak.vedtak.domain.VedtaksperiodeType
+import no.nav.familie.ef.sak.økonomi.lagTilkjentYtelse
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.util.UUID
+
+object VedtakDomeneParser {
+
+    val behandlingIdTilUUID = mapOf(1 to UUID.randomUUID(), 2 to UUID.randomUUID(), 3 to UUID.randomUUID())
+    val tilkjentYtelseIdNummerTilUUID = mapOf(1 to UUID.randomUUID(), 2 to UUID.randomUUID(), 3 to UUID.randomUUID())
+
+    fun mapVedtak(dataTable: DataTable): List<Vedtak> {
+        return dataTable.asMaps().map {
+            VedtakMapper().mapRad(it)
+        }
+    }
+
+    fun mapBehandlingForHistorikkEndring(dataTable: DataTable): List<ForventetHistorikk> {
+        return dataTable.asMaps().map {
+            BehandlingForHistorikkEndringMapper().mapRad(it)
+        }
+    }
+
+    class ForventetHistorikk(
+            val id: UUID,
+            val historikkEndring: HistorikkEndring?,
+            val inntekt: Int
+    )
+
+    fun mapAndelTilkjentYtelse(dataTable: DataTable): List<AndelTilkjentYtelse> {
+        return dataTable.asMaps().map {
+            AndelTilkjentYtelseMapper().mapRad(it)
+        }
+    }
+
+
+    fun lagDefaultTilkjentYtelseFraAndel(dataTable: DataTable): List<TilkjentYtelse> {
+        return dataTable.asMaps().map {
+            val andel = AndelTilkjentYtelseMapper().mapRad(it)
+            lagTilkjentYtelse(listOf(andel), UUID.randomUUID(), andel.kildeBehandlingId)
+        }
+    }
+
+    class VedtakMapper {
+
+        fun mapRad(rad: Map<String, String>): Vedtak {
+            return Vedtak(
+                    behandlingId = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.BEHANDLING_ID, rad)]!!,
+                    resultatType = parseResultatType(rad),
+                    perioder = PeriodeWrapper(listOf(Vedtaksperiode(LocalDate.now(),
+                                                                    LocalDate.now().plusYears(1),
+                                                                    AktivitetType.BARN_UNDER_ETT_ÅR,
+                                                                    VedtaksperiodeType.HOVEDPERIODE)))
+            )
+        }
+    }
+
+    class TilkjentYtelseMapper {
+
+        fun mapRad(rad: Map<String, String>): TilkjentYtelse {
+            return TilkjentYtelse(
+                    id = tilkjentYtelseIdNummerTilUUID[parseInt(VedtakDomenebegrep.TILKJENT_YTELSE_ID, rad)]!!,
+                    behandlingId = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.BEHANDLING_ID, rad)]!!,
+                    personident = parseString(VedtakDomenebegrep.PERSONIDENT, rad),
+                    vedtakstidspunkt = LocalDateTime.now(),
+                    type = TilkjentYtelseType.FØRSTEGANGSBEHANDLING,
+                    andelerTilkjentYtelse = listOf()
+            )
+        }
+    }
+
+    class AndelTilkjentYtelseMapper {
+
+        fun mapRad(rad: Map<String, String>): AndelTilkjentYtelse {
+            return AndelTilkjentYtelse(
+                    beløp = parseValgfriInt(VedtakDomenebegrep.BELØP, rad) ?: 0,
+                    stønadFom = parseValgfriDato(VedtakDomenebegrep.FRA_OG_MED_DATO, rad) ?: LocalDate.now(),
+                    stønadTom = parseValgfriDato(VedtakDomenebegrep.TIL_OG_MED_DATO, rad) ?: LocalDate.now().plusYears(1),
+                    personIdent = parseValgfriString(VedtakDomenebegrep.PERSONIDENT, rad) ?: "1",
+                    inntekt = parseValgfriInt(VedtakDomenebegrep.INNTEKT, rad) ?: 0,
+                    inntektsreduksjon = parseValgfriInt(VedtakDomenebegrep.INNTEKTSREDUKSJON, rad) ?: 0,
+                    samordningsfradrag = parseValgfriInt(VedtakDomenebegrep.SAMORDNINGSFRADRAG, rad) ?: 0,
+                    kildeBehandlingId = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.BEHANDLING_ID, rad)]!!
+            )
+        }
+    }
+
+    class BehandlingForHistorikkEndringMapper {
+
+        fun mapRad(rad: Map<String, String>): ForventetHistorikk {
+            if (parseEndringType(rad) == null) {
+                return ForventetHistorikk(
+                        id = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.BEHANDLING_ID, rad)]!!,
+                        historikkEndring = null,
+                        inntekt = parseInt(VedtakDomenebegrep.INNTEKT, rad)
+                )
+
+            }
+            return ForventetHistorikk(
+                    id = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.BEHANDLING_ID, rad)]!!,
+                    historikkEndring = HistorikkEndring(
+                            type = parseEndringType(rad)!!,
+                            behandlingId = behandlingIdTilUUID[parseInt(VedtakDomenebegrep.ENDRET_I_BEHANDLING_ID, rad)]!!,
+                            vedtakstidspunkt = LocalDateTime.now()
+                    ),
+                    inntekt = parseInt(VedtakDomenebegrep.INNTEKT, rad)
+            )
+        }
+    }
+
+}
+
+enum class VedtakDomenebegrep(val nøkkel: String) : Domenenøkkel {
+    RESULTAT_TYPE("Vedtaksresultat"),
+    TILKJENT_YTELSE_ID("Tilkjent ytelse Id"),
+    PERSONIDENT("Personnummer"),
+    INNTEKT("Inntekt"),
+    INNTEKTSREDUKSJON("Inntektsreduksjon"),
+    SAMORDNINGSFRADRAG("Samordningsfradrag"),
+    BELØP("Beløp"),
+    FRA_OG_MED_DATO("Fra og med dato"),
+    TIL_OG_MED_DATO("Til og med dato"),
+    BEHANDLING_ID("BehandlingId"),
+    ENDRET_I_BEHANDLING_ID("Endret i behandlingId"),
+    ENDRING_TYPE("Endringstype"),
+    HISTORIKKENDRING("Historikkendring"),
+    ;
+
+    override fun nøkkel(): String {
+        return nøkkel
+    }
+}