fix(server, shared): TODO
This commit is contained in:
@@ -1,4 +1,4 @@
|
||||
import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig
|
||||
|
||||
plugins {
|
||||
@@ -37,6 +37,12 @@ kotlin {
|
||||
}
|
||||
}
|
||||
|
||||
val commonTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
}
|
||||
}
|
||||
|
||||
// val jvmMain by getting {
|
||||
// dependsOn(commonMain)
|
||||
// }
|
||||
|
||||
+4
-4
@@ -1,8 +1,8 @@
|
||||
package at.mocode.model.entitaeten
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.model.serializers.BigDecimalSerializer
|
||||
import at.mocode.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.serializers.BigDecimalSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
package at.mocode.model.entitaeten
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.serialization.Serializable
|
||||
+3
-3
@@ -1,7 +1,7 @@
|
||||
package at.mocode.model.entitaeten
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.model.enums.PlatzTyp
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.enums.PlatzTyp
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.serialization.Serializable
|
||||
+8
-3
@@ -1,7 +1,12 @@
|
||||
package at.mocode.model.entitaeten
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.model.enums.NennungsArt
|
||||
import at.mocode.model.serializers.*
|
||||
|
||||
import at.mocode.shared.model.enums.NennungsArt
|
||||
import at.mocode.shared.model.serializers.BigDecimalSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateTimeSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
+5
-5
@@ -1,9 +1,9 @@
|
||||
package at.mocode.model.entitaeten
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.model.enums.VeranstalterTyp
|
||||
import at.mocode.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.enums.VeranstalterTyp
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package at.mocode.model.enums
|
||||
package at.mocode.shared.model.enums
|
||||
|
||||
import kotlinx.serialization.Serializable
|
||||
|
||||
+1
-1
@@ -1,4 +1,4 @@
|
||||
package at.mocode.model.serializers
|
||||
package at.mocode.shared.model.serializers
|
||||
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuidFrom
|
||||
+4
-4
@@ -1,8 +1,8 @@
|
||||
package at.mocode.model.stammdaten
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.model.enums.LizenzTyp
|
||||
import at.mocode.model.enums.Sparte
|
||||
import at.mocode.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.enums.LizenzTyp
|
||||
import at.mocode.shared.model.enums.Sparte
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.Serializable
|
||||
|
||||
+6
-6
@@ -1,10 +1,10 @@
|
||||
package at.mocode.model.stammdaten
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.model.enums.FunktionaerRolle
|
||||
import at.mocode.model.enums.Geschlecht
|
||||
import at.mocode.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.enums.FunktionaerRolle
|
||||
import at.mocode.shared.model.enums.Geschlecht
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
+4
-4
@@ -1,8 +1,8 @@
|
||||
package at.mocode.model.stammdaten
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.model.enums.GeschlechtPferd
|
||||
import at.mocode.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.enums.GeschlechtPferd
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
+3
-3
@@ -1,7 +1,7 @@
|
||||
package at.mocode.model.stammdaten
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.model.serializers.UuidSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
@@ -0,0 +1,161 @@
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.shared.model.serializers.BigDecimalSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class ArtikelTest {
|
||||
|
||||
@Test
|
||||
fun testCreateArtikel() {
|
||||
// Create an Artikel with minimal required parameters
|
||||
val artikel = Artikel(
|
||||
bezeichnung = "Test Artikel",
|
||||
preis = BigDecimal.parseString("10.50"),
|
||||
einheit = "Stück"
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("Test Artikel", artikel.bezeichnung)
|
||||
assertEquals(BigDecimal.parseString("10.50"), artikel.preis)
|
||||
assertEquals("Stück", artikel.einheit)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(artikel.id)
|
||||
assertEquals(false, artikel.istVerbandsabgabe)
|
||||
assertNotNull(artikel.createdAt)
|
||||
assertNotNull(artikel.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateArtikelWithAllParameters() {
|
||||
// Create an Artikel with all parameters
|
||||
val id = uuid4()
|
||||
val now = Clock.System.now()
|
||||
|
||||
val artikel = Artikel(
|
||||
id = id,
|
||||
bezeichnung = "Vollständiger Artikel",
|
||||
preis = BigDecimal.parseString("99.99"),
|
||||
einheit = "Paket",
|
||||
istVerbandsabgabe = true,
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, artikel.id)
|
||||
assertEquals("Vollständiger Artikel", artikel.bezeichnung)
|
||||
assertEquals(BigDecimal.parseString("99.99"), artikel.preis)
|
||||
assertEquals("Paket", artikel.einheit)
|
||||
assertEquals(true, artikel.istVerbandsabgabe)
|
||||
assertEquals(now, artikel.createdAt)
|
||||
assertEquals(now, artikel.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyArtikel() {
|
||||
// Create an Artikel
|
||||
val artikel = Artikel(
|
||||
bezeichnung = "Original Artikel",
|
||||
preis = BigDecimal.parseString("10.00"),
|
||||
einheit = "Stück"
|
||||
)
|
||||
|
||||
val originalUpdatedAt = artikel.updatedAt
|
||||
|
||||
// Modify properties
|
||||
artikel.bezeichnung = "Geänderter Artikel"
|
||||
artikel.preis = BigDecimal.parseString("15.00")
|
||||
artikel.einheit = "Box"
|
||||
artikel.istVerbandsabgabe = true
|
||||
artikel.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("Geänderter Artikel", artikel.bezeichnung)
|
||||
assertEquals(BigDecimal.parseString("15.00"), artikel.preis)
|
||||
assertEquals("Box", artikel.einheit)
|
||||
assertEquals(true, artikel.istVerbandsabgabe)
|
||||
assertNotEquals(originalUpdatedAt, artikel.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create an Artikel
|
||||
val artikel = Artikel(
|
||||
bezeichnung = "Serialisierter Artikel",
|
||||
preis = BigDecimal.parseString("25.75"),
|
||||
einheit = "Einheit",
|
||||
istVerbandsabgabe = true
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(artikel)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"bezeichnung\""), "JSON should contain bezeichnung field")
|
||||
assertTrue(jsonString.contains("\"Serialisierter Artikel\""), "JSON should contain value Serialisierter Artikel")
|
||||
assertTrue(jsonString.contains("\"preis\""), "JSON should contain preis field")
|
||||
assertTrue(jsonString.contains("\"25.75\""), "JSON should contain value 25.75")
|
||||
assertTrue(jsonString.contains("\"einheit\""), "JSON should contain einheit field")
|
||||
assertTrue(jsonString.contains("\"Einheit\""), "JSON should contain value Einheit")
|
||||
assertTrue(jsonString.contains("\"istVerbandsabgabe\""), "JSON should contain istVerbandsabgabe field")
|
||||
assertTrue(jsonString.contains("true"), "JSON should contain value true")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedArtikel = json.decodeFromString<Artikel>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(artikel.id, deserializedArtikel.id)
|
||||
assertEquals(artikel.bezeichnung, deserializedArtikel.bezeichnung)
|
||||
assertEquals(artikel.preis, deserializedArtikel.preis)
|
||||
assertEquals(artikel.einheit, deserializedArtikel.einheit)
|
||||
assertEquals(artikel.istVerbandsabgabe, deserializedArtikel.istVerbandsabgabe)
|
||||
assertEquals(artikel.createdAt, deserializedArtikel.createdAt)
|
||||
assertEquals(artikel.updatedAt, deserializedArtikel.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyArtikel() {
|
||||
// Create an Artikel
|
||||
val original = Artikel(
|
||||
bezeichnung = "Original Artikel",
|
||||
preis = BigDecimal.parseString("10.00"),
|
||||
einheit = "Stück"
|
||||
)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
bezeichnung = "Kopierter Artikel",
|
||||
preis = BigDecimal.parseString("12.50")
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.einheit, copy.einheit)
|
||||
assertEquals(original.istVerbandsabgabe, copy.istVerbandsabgabe)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Kopierter Artikel", copy.bezeichnung)
|
||||
assertEquals(BigDecimal.parseString("12.50"), copy.preis)
|
||||
}
|
||||
}
|
||||
+169
@@ -0,0 +1,169 @@
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class MeisterschaftReferenzTest {
|
||||
|
||||
@Test
|
||||
fun testCreateMeisterschaftReferenz() {
|
||||
// Create a MeisterschaftReferenz with minimal required parameters
|
||||
val meisterschaftId = uuid4()
|
||||
val meisterschaftReferenz = MeisterschaftReferenz(
|
||||
meisterschaftId = meisterschaftId,
|
||||
name = "Test Meisterschaft",
|
||||
betrifftBewerbNummern = listOf(1, 2, 3),
|
||||
berechnungsstrategie = null,
|
||||
reglementUrl = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals(meisterschaftId, meisterschaftReferenz.meisterschaftId)
|
||||
assertEquals("Test Meisterschaft", meisterschaftReferenz.name)
|
||||
assertEquals(listOf(1, 2, 3), meisterschaftReferenz.betrifftBewerbNummern)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(meisterschaftReferenz.id)
|
||||
assertEquals(null, meisterschaftReferenz.berechnungsstrategie)
|
||||
assertEquals(null, meisterschaftReferenz.reglementUrl)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateMeisterschaftReferenzWithAllParameters() {
|
||||
// Create a MeisterschaftReferenz with all parameters
|
||||
val id = uuid4()
|
||||
val meisterschaftId = uuid4()
|
||||
|
||||
val meisterschaftReferenz = MeisterschaftReferenz(
|
||||
id = id,
|
||||
meisterschaftId = meisterschaftId,
|
||||
name = "Vollständige Meisterschaft",
|
||||
betrifftBewerbNummern = listOf(10, 20, 30),
|
||||
berechnungsstrategie = "Punktesystem A",
|
||||
reglementUrl = "https://example.com/reglement"
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, meisterschaftReferenz.id)
|
||||
assertEquals(meisterschaftId, meisterschaftReferenz.meisterschaftId)
|
||||
assertEquals("Vollständige Meisterschaft", meisterschaftReferenz.name)
|
||||
assertEquals(listOf(10, 20, 30), meisterschaftReferenz.betrifftBewerbNummern)
|
||||
assertEquals("Punktesystem A", meisterschaftReferenz.berechnungsstrategie)
|
||||
assertEquals("https://example.com/reglement", meisterschaftReferenz.reglementUrl)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyMeisterschaftReferenz() {
|
||||
// Create a MeisterschaftReferenz
|
||||
val meisterschaftId = uuid4()
|
||||
val meisterschaftReferenz = MeisterschaftReferenz(
|
||||
meisterschaftId = meisterschaftId,
|
||||
name = "Original Meisterschaft",
|
||||
betrifftBewerbNummern = listOf(1, 2, 3),
|
||||
berechnungsstrategie = null,
|
||||
reglementUrl = null
|
||||
)
|
||||
|
||||
val newMeisterschaftId = uuid4()
|
||||
|
||||
// Modify properties
|
||||
meisterschaftReferenz.meisterschaftId = newMeisterschaftId
|
||||
meisterschaftReferenz.name = "Geänderte Meisterschaft"
|
||||
meisterschaftReferenz.betrifftBewerbNummern = listOf(4, 5, 6)
|
||||
meisterschaftReferenz.berechnungsstrategie = "Neues Punktesystem"
|
||||
meisterschaftReferenz.reglementUrl = "https://example.com/neues-reglement"
|
||||
|
||||
// Verify modifications
|
||||
assertEquals(newMeisterschaftId, meisterschaftReferenz.meisterschaftId)
|
||||
assertEquals("Geänderte Meisterschaft", meisterschaftReferenz.name)
|
||||
assertEquals(listOf(4, 5, 6), meisterschaftReferenz.betrifftBewerbNummern)
|
||||
assertEquals("Neues Punktesystem", meisterschaftReferenz.berechnungsstrategie)
|
||||
assertEquals("https://example.com/neues-reglement", meisterschaftReferenz.reglementUrl)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a MeisterschaftReferenz
|
||||
val meisterschaftId = uuid4()
|
||||
val meisterschaftReferenz = MeisterschaftReferenz(
|
||||
meisterschaftId = meisterschaftId,
|
||||
name = "Serialisierte Meisterschaft",
|
||||
betrifftBewerbNummern = listOf(7, 8, 9),
|
||||
berechnungsstrategie = "Punktesystem B",
|
||||
reglementUrl = "https://example.com/serialisiert"
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(meisterschaftReferenz)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"meisterschaftId\""), "JSON should contain meisterschaftId field")
|
||||
assertTrue(jsonString.contains(meisterschaftId.toString()), "JSON should contain meisterschaftId value")
|
||||
assertTrue(jsonString.contains("\"name\""), "JSON should contain name field")
|
||||
assertTrue(jsonString.contains("\"Serialisierte Meisterschaft\""), "JSON should contain name value")
|
||||
assertTrue(jsonString.contains("\"betrifftBewerbNummern\""), "JSON should contain betrifftBewerbNummern field")
|
||||
assertTrue(jsonString.contains("7"), "JSON should contain betrifftBewerbNummern value 7")
|
||||
assertTrue(jsonString.contains("8"), "JSON should contain betrifftBewerbNummern value 8")
|
||||
assertTrue(jsonString.contains("9"), "JSON should contain betrifftBewerbNummern value 9")
|
||||
assertTrue(jsonString.contains("\"berechnungsstrategie\""), "JSON should contain berechnungsstrategie field")
|
||||
assertTrue(jsonString.contains("\"Punktesystem B\""), "JSON should contain berechnungsstrategie value")
|
||||
assertTrue(jsonString.contains("\"reglementUrl\""), "JSON should contain reglementUrl field")
|
||||
assertTrue(jsonString.contains("\"https://example.com/serialisiert\""), "JSON should contain reglementUrl value")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedMeisterschaftReferenz = json.decodeFromString<MeisterschaftReferenz>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(meisterschaftReferenz.id, deserializedMeisterschaftReferenz.id)
|
||||
assertEquals(meisterschaftReferenz.meisterschaftId, deserializedMeisterschaftReferenz.meisterschaftId)
|
||||
assertEquals(meisterschaftReferenz.name, deserializedMeisterschaftReferenz.name)
|
||||
assertEquals(meisterschaftReferenz.betrifftBewerbNummern, deserializedMeisterschaftReferenz.betrifftBewerbNummern)
|
||||
assertEquals(meisterschaftReferenz.berechnungsstrategie, deserializedMeisterschaftReferenz.berechnungsstrategie)
|
||||
assertEquals(meisterschaftReferenz.reglementUrl, deserializedMeisterschaftReferenz.reglementUrl)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyMeisterschaftReferenz() {
|
||||
// Create a MeisterschaftReferenz
|
||||
val meisterschaftId = uuid4()
|
||||
val original = MeisterschaftReferenz(
|
||||
meisterschaftId = meisterschaftId,
|
||||
name = "Original Meisterschaft",
|
||||
betrifftBewerbNummern = listOf(1, 2, 3),
|
||||
berechnungsstrategie = "Original Strategie",
|
||||
reglementUrl = null
|
||||
)
|
||||
|
||||
val newMeisterschaftId = uuid4()
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
name = "Kopierte Meisterschaft",
|
||||
meisterschaftId = newMeisterschaftId,
|
||||
reglementUrl = "https://example.com/kopie"
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.betrifftBewerbNummern, copy.betrifftBewerbNummern)
|
||||
assertEquals(original.berechnungsstrategie, copy.berechnungsstrategie)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Kopierte Meisterschaft", copy.name)
|
||||
assertEquals(newMeisterschaftId, copy.meisterschaftId)
|
||||
assertEquals("https://example.com/kopie", copy.reglementUrl)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.shared.model.enums.PlatzTyp
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class PlatzTest {
|
||||
|
||||
@Test
|
||||
fun testCreatePlatz() {
|
||||
// Create a Platz with minimal required parameters
|
||||
val platz = Platz(
|
||||
name = "Hauptplatz",
|
||||
dimension = null,
|
||||
boden = null,
|
||||
typ = PlatzTyp.AUSTRAGUNG
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("Hauptplatz", platz.name)
|
||||
assertEquals(PlatzTyp.AUSTRAGUNG, platz.typ)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(platz.id)
|
||||
assertEquals(null, platz.dimension)
|
||||
assertEquals(null, platz.boden)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreatePlatzWithAllParameters() {
|
||||
// Create a Platz with all parameters
|
||||
val id = uuid4()
|
||||
|
||||
val platz = Platz(
|
||||
id = id,
|
||||
name = "Vollständiger Platz",
|
||||
dimension = "60x20m",
|
||||
boden = "Sand",
|
||||
typ = PlatzTyp.VORBEREITUNG
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, platz.id)
|
||||
assertEquals("Vollständiger Platz", platz.name)
|
||||
assertEquals("60x20m", platz.dimension)
|
||||
assertEquals("Sand", platz.boden)
|
||||
assertEquals(PlatzTyp.VORBEREITUNG, platz.typ)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyPlatz() {
|
||||
// Create a Platz
|
||||
val platz = Platz(
|
||||
name = "Original Platz",
|
||||
dimension = null,
|
||||
boden = null,
|
||||
typ = PlatzTyp.AUSTRAGUNG
|
||||
)
|
||||
|
||||
// Modify properties
|
||||
platz.name = "Geänderter Platz"
|
||||
platz.dimension = "80x40m"
|
||||
platz.boden = "Gras"
|
||||
platz.typ = PlatzTyp.LONGIEREN
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("Geänderter Platz", platz.name)
|
||||
assertEquals("80x40m", platz.dimension)
|
||||
assertEquals("Gras", platz.boden)
|
||||
assertEquals(PlatzTyp.LONGIEREN, platz.typ)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a Platz
|
||||
val platz = Platz(
|
||||
name = "Serialisierter Platz",
|
||||
dimension = "70x30m",
|
||||
boden = "Kunstrasen",
|
||||
typ = PlatzTyp.SONSTIGES
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(platz)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"name\""), "JSON should contain name field")
|
||||
assertTrue(jsonString.contains("\"Serialisierter Platz\""), "JSON should contain name value")
|
||||
assertTrue(jsonString.contains("\"dimension\""), "JSON should contain dimension field")
|
||||
assertTrue(jsonString.contains("\"70x30m\""), "JSON should contain dimension value")
|
||||
assertTrue(jsonString.contains("\"boden\""), "JSON should contain boden field")
|
||||
assertTrue(jsonString.contains("\"Kunstrasen\""), "JSON should contain boden value")
|
||||
assertTrue(jsonString.contains("\"typ\""), "JSON should contain typ field")
|
||||
assertTrue(jsonString.contains("\"SONSTIGES\""), "JSON should contain typ value")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedPlatz = json.decodeFromString<Platz>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(platz.id, deserializedPlatz.id)
|
||||
assertEquals(platz.name, deserializedPlatz.name)
|
||||
assertEquals(platz.dimension, deserializedPlatz.dimension)
|
||||
assertEquals(platz.boden, deserializedPlatz.boden)
|
||||
assertEquals(platz.typ, deserializedPlatz.typ)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyPlatz() {
|
||||
// Create a Platz
|
||||
val original = Platz(
|
||||
name = "Original Platz",
|
||||
dimension = "50x25m",
|
||||
boden = "Holzspäne",
|
||||
typ = PlatzTyp.VORBEREITUNG
|
||||
)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
name = "Kopierter Platz",
|
||||
typ = PlatzTyp.LONGIEREN
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.dimension, copy.dimension)
|
||||
assertEquals(original.boden, copy.boden)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Kopierter Platz", copy.name)
|
||||
assertEquals(PlatzTyp.LONGIEREN, copy.typ)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,441 @@
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.shared.model.enums.NennungsArt
|
||||
import at.mocode.shared.model.enums.PlatzTyp
|
||||
import at.mocode.shared.model.serializers.BigDecimalSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateTimeSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.datetime.LocalDateTime
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class TurnierTest {
|
||||
|
||||
@Test
|
||||
fun testCreateTurnier() {
|
||||
// Create a Turnier with minimal required parameters
|
||||
val veranstaltungId = uuid4()
|
||||
val datumVon = LocalDate(2023, 6, 1)
|
||||
val datumBis = LocalDate(2023, 6, 3)
|
||||
|
||||
val turnier = Turnier(
|
||||
veranstaltungId = veranstaltungId,
|
||||
oepsTurnierNr = "T12345",
|
||||
titel = "Test Turnier",
|
||||
untertitel = null,
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
nennungsschluss = null,
|
||||
nennungsHinweis = null,
|
||||
eigenesNennsystemUrl = null,
|
||||
nenngeld = null,
|
||||
startgeldStandard = null,
|
||||
turnierleiterId = null,
|
||||
turnierbeauftragterId = null,
|
||||
tierarztInfos = null,
|
||||
hufschmiedInfo = null,
|
||||
meldestelleVerantwortlicherId = null,
|
||||
meldestelleTelefon = null,
|
||||
meldestelleOeffnungszeiten = null,
|
||||
ergebnislistenUrl = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals(veranstaltungId, turnier.veranstaltungId)
|
||||
assertEquals("T12345", turnier.oepsTurnierNr)
|
||||
assertEquals("Test Turnier", turnier.titel)
|
||||
assertEquals(datumVon, turnier.datumVon)
|
||||
assertEquals(datumBis, turnier.datumBis)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(turnier.id)
|
||||
assertEquals(null, turnier.untertitel)
|
||||
assertEquals(null, turnier.nennungsschluss)
|
||||
assertTrue(turnier.nennungsArt.isEmpty())
|
||||
assertEquals(null, turnier.nennungsHinweis)
|
||||
assertEquals(null, turnier.eigenesNennsystemUrl)
|
||||
assertEquals(null, turnier.nenngeld)
|
||||
assertEquals(null, turnier.startgeldStandard)
|
||||
assertTrue(turnier.austragungsplaetze.isEmpty())
|
||||
assertTrue(turnier.vorbereitungsplaetze.isEmpty())
|
||||
assertEquals(null, turnier.turnierleiterId)
|
||||
assertEquals(null, turnier.turnierbeauftragterId)
|
||||
assertTrue(turnier.richterIds.isEmpty())
|
||||
assertTrue(turnier.parcoursbauerIds.isEmpty())
|
||||
assertTrue(turnier.parcoursAssistentIds.isEmpty())
|
||||
assertEquals(null, turnier.tierarztInfos)
|
||||
assertEquals(null, turnier.hufschmiedInfo)
|
||||
assertEquals(null, turnier.meldestelleVerantwortlicherId)
|
||||
assertEquals(null, turnier.meldestelleTelefon)
|
||||
assertEquals(null, turnier.meldestelleOeffnungszeiten)
|
||||
assertEquals(null, turnier.ergebnislistenUrl)
|
||||
assertTrue(turnier.verfuegbareArtikel.isEmpty())
|
||||
assertTrue(turnier.meisterschaftRefs.isEmpty())
|
||||
assertNotNull(turnier.createdAt)
|
||||
assertNotNull(turnier.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateTurnierWithAllParameters() {
|
||||
// Create a Turnier with all parameters
|
||||
val id = uuid4()
|
||||
val veranstaltungId = uuid4()
|
||||
val datumVon = LocalDate(2023, 7, 15)
|
||||
val datumBis = LocalDate(2023, 7, 17)
|
||||
val nennungsschluss = LocalDateTime(2023, 7, 10, 23, 59, 59)
|
||||
val turnierleiterId = uuid4()
|
||||
val turnierbeauftragterId = uuid4()
|
||||
val meldestelleVerantwortlicherId = uuid4()
|
||||
val now = Clock.System.now()
|
||||
|
||||
// Create some test objects for lists
|
||||
val nennungsArt = listOf(NennungsArt.OEPS_ZNS, NennungsArt.EIGENES_ONLINE)
|
||||
val austragungsplatz = Platz(name = "Hauptplatz", dimension = "60x20m", boden = "Sand", typ = PlatzTyp.AUSTRAGUNG)
|
||||
val vorbereitungsplatz = Platz(name = "Abreiteplatz", dimension = "40x20m", boden = "Sand", typ = PlatzTyp.VORBEREITUNG)
|
||||
val richterIds = listOf(uuid4(), uuid4())
|
||||
val parcoursbauerIds = listOf(uuid4())
|
||||
val parcoursAssistentIds = listOf(uuid4())
|
||||
val artikel = Artikel(bezeichnung = "Startgebühr", preis = BigDecimal.parseString("25.00"), einheit = "Start")
|
||||
val meisterschaftRef = MeisterschaftReferenz(
|
||||
meisterschaftId = uuid4(),
|
||||
name = "Landesmeisterschaft",
|
||||
betrifftBewerbNummern = listOf(1, 2, 3),
|
||||
berechnungsstrategie = "Standard",
|
||||
reglementUrl = null
|
||||
)
|
||||
|
||||
val turnier = Turnier(
|
||||
id = id,
|
||||
veranstaltungId = veranstaltungId,
|
||||
oepsTurnierNr = "T67890",
|
||||
titel = "Vollständiges Turnier",
|
||||
untertitel = "Mit allen Details",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
nennungsschluss = nennungsschluss,
|
||||
nennungsArt = nennungsArt,
|
||||
nennungsHinweis = "Bitte rechtzeitig nennen",
|
||||
eigenesNennsystemUrl = "https://example.com/nennung",
|
||||
nenngeld = BigDecimal.parseString("50.00"),
|
||||
startgeldStandard = BigDecimal.parseString("25.00"),
|
||||
austragungsplaetze = listOf(austragungsplatz),
|
||||
vorbereitungsplaetze = listOf(vorbereitungsplatz),
|
||||
turnierleiterId = turnierleiterId,
|
||||
turnierbeauftragterId = turnierbeauftragterId,
|
||||
richterIds = richterIds,
|
||||
parcoursbauerIds = parcoursbauerIds,
|
||||
parcoursAssistentIds = parcoursAssistentIds,
|
||||
tierarztInfos = "Dr. Vet, Tel: 12345",
|
||||
hufschmiedInfo = "Hans Schmidt, Tel: 67890",
|
||||
meldestelleVerantwortlicherId = meldestelleVerantwortlicherId,
|
||||
meldestelleTelefon = "+43 123 456789",
|
||||
meldestelleOeffnungszeiten = "8-18 Uhr",
|
||||
ergebnislistenUrl = "https://example.com/ergebnisse",
|
||||
verfuegbareArtikel = listOf(artikel),
|
||||
meisterschaftRefs = listOf(meisterschaftRef),
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, turnier.id)
|
||||
assertEquals(veranstaltungId, turnier.veranstaltungId)
|
||||
assertEquals("T67890", turnier.oepsTurnierNr)
|
||||
assertEquals("Vollständiges Turnier", turnier.titel)
|
||||
assertEquals("Mit allen Details", turnier.untertitel)
|
||||
assertEquals(datumVon, turnier.datumVon)
|
||||
assertEquals(datumBis, turnier.datumBis)
|
||||
assertEquals(nennungsschluss, turnier.nennungsschluss)
|
||||
assertEquals(nennungsArt, turnier.nennungsArt)
|
||||
assertEquals("Bitte rechtzeitig nennen", turnier.nennungsHinweis)
|
||||
assertEquals("https://example.com/nennung", turnier.eigenesNennsystemUrl)
|
||||
assertEquals(BigDecimal.parseString("50.00"), turnier.nenngeld)
|
||||
assertEquals(BigDecimal.parseString("25.00"), turnier.startgeldStandard)
|
||||
assertEquals(1, turnier.austragungsplaetze.size)
|
||||
assertEquals(austragungsplatz.name, turnier.austragungsplaetze[0].name)
|
||||
assertEquals(1, turnier.vorbereitungsplaetze.size)
|
||||
assertEquals(vorbereitungsplatz.name, turnier.vorbereitungsplaetze[0].name)
|
||||
assertEquals(turnierleiterId, turnier.turnierleiterId)
|
||||
assertEquals(turnierbeauftragterId, turnier.turnierbeauftragterId)
|
||||
assertEquals(richterIds, turnier.richterIds)
|
||||
assertEquals(parcoursbauerIds, turnier.parcoursbauerIds)
|
||||
assertEquals(parcoursAssistentIds, turnier.parcoursAssistentIds)
|
||||
assertEquals("Dr. Vet, Tel: 12345", turnier.tierarztInfos)
|
||||
assertEquals("Hans Schmidt, Tel: 67890", turnier.hufschmiedInfo)
|
||||
assertEquals(meldestelleVerantwortlicherId, turnier.meldestelleVerantwortlicherId)
|
||||
assertEquals("+43 123 456789", turnier.meldestelleTelefon)
|
||||
assertEquals("8-18 Uhr", turnier.meldestelleOeffnungszeiten)
|
||||
assertEquals("https://example.com/ergebnisse", turnier.ergebnislistenUrl)
|
||||
assertEquals(1, turnier.verfuegbareArtikel.size)
|
||||
assertEquals(artikel.bezeichnung, turnier.verfuegbareArtikel[0].bezeichnung)
|
||||
assertEquals(1, turnier.meisterschaftRefs.size)
|
||||
assertEquals(meisterschaftRef.name, turnier.meisterschaftRefs[0].name)
|
||||
assertEquals(now, turnier.createdAt)
|
||||
assertEquals(now, turnier.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyTurnier() {
|
||||
// Create a Turnier
|
||||
val veranstaltungId = uuid4()
|
||||
val datumVon = LocalDate(2023, 8, 1)
|
||||
val datumBis = LocalDate(2023, 8, 3)
|
||||
|
||||
val turnier = Turnier(
|
||||
veranstaltungId = veranstaltungId,
|
||||
oepsTurnierNr = "T12345",
|
||||
titel = "Original Turnier",
|
||||
untertitel = null,
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
nennungsschluss = null,
|
||||
nennungsHinweis = null,
|
||||
eigenesNennsystemUrl = null,
|
||||
nenngeld = null,
|
||||
startgeldStandard = null,
|
||||
turnierleiterId = null,
|
||||
turnierbeauftragterId = null,
|
||||
tierarztInfos = null,
|
||||
hufschmiedInfo = null,
|
||||
meldestelleVerantwortlicherId = null,
|
||||
meldestelleTelefon = null,
|
||||
meldestelleOeffnungszeiten = null,
|
||||
ergebnislistenUrl = null
|
||||
)
|
||||
|
||||
val originalUpdatedAt = turnier.updatedAt
|
||||
val newVeranstaltungId = uuid4()
|
||||
val newDatumVon = LocalDate(2023, 9, 1)
|
||||
val newDatumBis = LocalDate(2023, 9, 3)
|
||||
val newNennungsschluss = LocalDateTime(2023, 8, 25, 23, 59, 59)
|
||||
val newTurnierleiterId = uuid4()
|
||||
val newTurnierbeauftragterId = uuid4()
|
||||
val newMeldestelleVerantwortlicherId = uuid4()
|
||||
|
||||
// Create some test objects for lists
|
||||
val nennungsArt = listOf(NennungsArt.DIREKT_VERANSTALTER_EMAIL)
|
||||
val austragungsplatz = Platz(name = "Neuer Hauptplatz", dimension = "70x30m", boden = "Gras", typ = PlatzTyp.AUSTRAGUNG)
|
||||
val richterIds = listOf(uuid4())
|
||||
val artikel = Artikel(bezeichnung = "Neue Startgebühr", preis = BigDecimal.parseString("30.00"), einheit = "Start")
|
||||
|
||||
// Modify properties
|
||||
turnier.veranstaltungId = newVeranstaltungId
|
||||
turnier.oepsTurnierNr = "T54321"
|
||||
turnier.titel = "Geändertes Turnier"
|
||||
turnier.untertitel = "Mit Untertitel"
|
||||
turnier.datumVon = newDatumVon
|
||||
turnier.datumBis = newDatumBis
|
||||
turnier.nennungsschluss = newNennungsschluss
|
||||
turnier.nennungsArt = nennungsArt
|
||||
turnier.nennungsHinweis = "Neuer Hinweis"
|
||||
turnier.eigenesNennsystemUrl = "https://example.com/neues-system"
|
||||
turnier.nenngeld = BigDecimal.parseString("60.00")
|
||||
turnier.startgeldStandard = BigDecimal.parseString("35.00")
|
||||
turnier.austragungsplaetze = listOf(austragungsplatz)
|
||||
turnier.turnierleiterId = newTurnierleiterId
|
||||
turnier.turnierbeauftragterId = newTurnierbeauftragterId
|
||||
turnier.richterIds = richterIds
|
||||
turnier.tierarztInfos = "Neuer Tierarzt"
|
||||
turnier.hufschmiedInfo = "Neuer Hufschmied"
|
||||
turnier.meldestelleVerantwortlicherId = newMeldestelleVerantwortlicherId
|
||||
turnier.meldestelleTelefon = "+43 987 654321"
|
||||
turnier.meldestelleOeffnungszeiten = "9-17 Uhr"
|
||||
turnier.ergebnislistenUrl = "https://example.com/neue-ergebnisse"
|
||||
turnier.verfuegbareArtikel = listOf(artikel)
|
||||
turnier.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals(newVeranstaltungId, turnier.veranstaltungId)
|
||||
assertEquals("T54321", turnier.oepsTurnierNr)
|
||||
assertEquals("Geändertes Turnier", turnier.titel)
|
||||
assertEquals("Mit Untertitel", turnier.untertitel)
|
||||
assertEquals(newDatumVon, turnier.datumVon)
|
||||
assertEquals(newDatumBis, turnier.datumBis)
|
||||
assertEquals(newNennungsschluss, turnier.nennungsschluss)
|
||||
assertEquals(nennungsArt, turnier.nennungsArt)
|
||||
assertEquals("Neuer Hinweis", turnier.nennungsHinweis)
|
||||
assertEquals("https://example.com/neues-system", turnier.eigenesNennsystemUrl)
|
||||
assertEquals(BigDecimal.parseString("60.00"), turnier.nenngeld)
|
||||
assertEquals(BigDecimal.parseString("35.00"), turnier.startgeldStandard)
|
||||
assertEquals(1, turnier.austragungsplaetze.size)
|
||||
assertEquals("Neuer Hauptplatz", turnier.austragungsplaetze[0].name)
|
||||
assertEquals(newTurnierleiterId, turnier.turnierleiterId)
|
||||
assertEquals(newTurnierbeauftragterId, turnier.turnierbeauftragterId)
|
||||
assertEquals(richterIds, turnier.richterIds)
|
||||
assertEquals("Neuer Tierarzt", turnier.tierarztInfos)
|
||||
assertEquals("Neuer Hufschmied", turnier.hufschmiedInfo)
|
||||
assertEquals(newMeldestelleVerantwortlicherId, turnier.meldestelleVerantwortlicherId)
|
||||
assertEquals("+43 987 654321", turnier.meldestelleTelefon)
|
||||
assertEquals("9-17 Uhr", turnier.meldestelleOeffnungszeiten)
|
||||
assertEquals("https://example.com/neue-ergebnisse", turnier.ergebnislistenUrl)
|
||||
assertEquals(1, turnier.verfuegbareArtikel.size)
|
||||
assertEquals("Neue Startgebühr", turnier.verfuegbareArtikel[0].bezeichnung)
|
||||
assertNotEquals(originalUpdatedAt, turnier.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a simplified Turnier for serialization testing
|
||||
val veranstaltungId = uuid4()
|
||||
val datumVon = LocalDate(2023, 10, 1)
|
||||
val datumBis = LocalDate(2023, 10, 3)
|
||||
val turnierleiterId = uuid4()
|
||||
|
||||
val turnier = Turnier(
|
||||
veranstaltungId = veranstaltungId,
|
||||
oepsTurnierNr = "T12345",
|
||||
titel = "Serialisiertes Turnier",
|
||||
untertitel = "Für Test",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
nennungsschluss = null,
|
||||
nennungsArt = listOf(NennungsArt.OEPS_ZNS),
|
||||
nennungsHinweis = "Hinweis",
|
||||
eigenesNennsystemUrl = null,
|
||||
nenngeld = BigDecimal.parseString("40.00"),
|
||||
startgeldStandard = null,
|
||||
turnierleiterId = turnierleiterId,
|
||||
turnierbeauftragterId = null,
|
||||
tierarztInfos = "Tierarzt Info",
|
||||
hufschmiedInfo = null,
|
||||
meldestelleVerantwortlicherId = null,
|
||||
meldestelleTelefon = "+43 123 456789",
|
||||
meldestelleOeffnungszeiten = null,
|
||||
ergebnislistenUrl = null
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(turnier)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"veranstaltungId\""), "JSON should contain veranstaltungId field")
|
||||
assertTrue(jsonString.contains(veranstaltungId.toString()), "JSON should contain veranstaltungId value")
|
||||
assertTrue(jsonString.contains("\"oepsTurnierNr\""), "JSON should contain oepsTurnierNr field")
|
||||
assertTrue(jsonString.contains("\"T12345\""), "JSON should contain oepsTurnierNr value")
|
||||
assertTrue(jsonString.contains("\"titel\""), "JSON should contain titel field")
|
||||
assertTrue(jsonString.contains("\"Serialisiertes Turnier\""), "JSON should contain titel value")
|
||||
assertTrue(jsonString.contains("\"datumVon\""), "JSON should contain datumVon field")
|
||||
assertTrue(jsonString.contains("\"2023-10-01\""), "JSON should contain datumVon value")
|
||||
assertTrue(jsonString.contains("\"nennungsArt\""), "JSON should contain nennungsArt field")
|
||||
assertTrue(jsonString.contains("\"OEPS_ZNS\""), "JSON should contain nennungsArt value")
|
||||
assertTrue(jsonString.contains("\"nenngeld\""), "JSON should contain nenngeld field")
|
||||
assertTrue(jsonString.contains("40"), "JSON should contain nenngeld value")
|
||||
assertTrue(jsonString.contains("\"turnierleiterId\""), "JSON should contain turnierleiterId field")
|
||||
assertTrue(jsonString.contains(turnierleiterId.toString()), "JSON should contain turnierleiterId value")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedTurnier = json.decodeFromString<Turnier>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(turnier.id, deserializedTurnier.id)
|
||||
assertEquals(turnier.veranstaltungId, deserializedTurnier.veranstaltungId)
|
||||
assertEquals(turnier.oepsTurnierNr, deserializedTurnier.oepsTurnierNr)
|
||||
assertEquals(turnier.titel, deserializedTurnier.titel)
|
||||
assertEquals(turnier.untertitel, deserializedTurnier.untertitel)
|
||||
assertEquals(turnier.datumVon, deserializedTurnier.datumVon)
|
||||
assertEquals(turnier.datumBis, deserializedTurnier.datumBis)
|
||||
assertEquals(turnier.nennungsArt, deserializedTurnier.nennungsArt)
|
||||
assertEquals(turnier.nennungsHinweis, deserializedTurnier.nennungsHinweis)
|
||||
assertEquals(turnier.nenngeld, deserializedTurnier.nenngeld)
|
||||
assertEquals(turnier.turnierleiterId, deserializedTurnier.turnierleiterId)
|
||||
assertEquals(turnier.tierarztInfos, deserializedTurnier.tierarztInfos)
|
||||
assertEquals(turnier.meldestelleTelefon, deserializedTurnier.meldestelleTelefon)
|
||||
assertEquals(turnier.createdAt, deserializedTurnier.createdAt)
|
||||
assertEquals(turnier.updatedAt, deserializedTurnier.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyTurnier() {
|
||||
// Create a Turnier
|
||||
val veranstaltungId = uuid4()
|
||||
val datumVon = LocalDate(2023, 11, 1)
|
||||
val datumBis = LocalDate(2023, 11, 3)
|
||||
|
||||
val original = Turnier(
|
||||
veranstaltungId = veranstaltungId,
|
||||
oepsTurnierNr = "T12345",
|
||||
titel = "Original Turnier",
|
||||
untertitel = "Original Untertitel",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
nennungsschluss = null,
|
||||
nennungsHinweis = "Original Hinweis",
|
||||
eigenesNennsystemUrl = null,
|
||||
nenngeld = BigDecimal.parseString("50.00"),
|
||||
startgeldStandard = null,
|
||||
turnierleiterId = null,
|
||||
turnierbeauftragterId = null,
|
||||
tierarztInfos = null,
|
||||
hufschmiedInfo = null,
|
||||
meldestelleVerantwortlicherId = null,
|
||||
meldestelleTelefon = null,
|
||||
meldestelleOeffnungszeiten = null,
|
||||
ergebnislistenUrl = null
|
||||
)
|
||||
|
||||
val newVeranstaltungId = uuid4()
|
||||
val newDatumVon = LocalDate(2023, 12, 1)
|
||||
val newDatumBis = LocalDate(2023, 12, 3)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
veranstaltungId = newVeranstaltungId,
|
||||
titel = "Kopiertes Turnier",
|
||||
datumVon = newDatumVon,
|
||||
datumBis = newDatumBis,
|
||||
nenngeld = BigDecimal.parseString("60.00")
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.oepsTurnierNr, copy.oepsTurnierNr)
|
||||
assertEquals(original.untertitel, copy.untertitel)
|
||||
assertEquals(original.nennungsschluss, copy.nennungsschluss)
|
||||
assertEquals(original.nennungsArt, copy.nennungsArt)
|
||||
assertEquals(original.nennungsHinweis, copy.nennungsHinweis)
|
||||
assertEquals(original.eigenesNennsystemUrl, copy.eigenesNennsystemUrl)
|
||||
assertEquals(original.startgeldStandard, copy.startgeldStandard)
|
||||
assertEquals(original.austragungsplaetze, copy.austragungsplaetze)
|
||||
assertEquals(original.vorbereitungsplaetze, copy.vorbereitungsplaetze)
|
||||
assertEquals(original.turnierleiterId, copy.turnierleiterId)
|
||||
assertEquals(original.turnierbeauftragterId, copy.turnierbeauftragterId)
|
||||
assertEquals(original.richterIds, copy.richterIds)
|
||||
assertEquals(original.parcoursbauerIds, copy.parcoursbauerIds)
|
||||
assertEquals(original.parcoursAssistentIds, copy.parcoursAssistentIds)
|
||||
assertEquals(original.tierarztInfos, copy.tierarztInfos)
|
||||
assertEquals(original.hufschmiedInfo, copy.hufschmiedInfo)
|
||||
assertEquals(original.meldestelleVerantwortlicherId, copy.meldestelleVerantwortlicherId)
|
||||
assertEquals(original.meldestelleTelefon, copy.meldestelleTelefon)
|
||||
assertEquals(original.meldestelleOeffnungszeiten, copy.meldestelleOeffnungszeiten)
|
||||
assertEquals(original.ergebnislistenUrl, copy.ergebnislistenUrl)
|
||||
assertEquals(original.verfuegbareArtikel, copy.verfuegbareArtikel)
|
||||
assertEquals(original.meisterschaftRefs, copy.meisterschaftRefs)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals(newVeranstaltungId, copy.veranstaltungId)
|
||||
assertEquals("Kopiertes Turnier", copy.titel)
|
||||
assertEquals(newDatumVon, copy.datumVon)
|
||||
assertEquals(newDatumBis, copy.datumBis)
|
||||
assertEquals(BigDecimal.parseString("60.00"), copy.nenngeld)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,341 @@
|
||||
package at.mocode.shared.model.entitaeten
|
||||
|
||||
import at.mocode.shared.model.enums.VeranstalterTyp
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class VeranstaltungTest {
|
||||
|
||||
@Test
|
||||
fun testCreateVeranstaltung() {
|
||||
// Create a Veranstaltung with minimal required parameters
|
||||
val datumVon = LocalDate(2023, 6, 1)
|
||||
val datumBis = LocalDate(2023, 6, 3)
|
||||
|
||||
val veranstaltung = Veranstaltung(
|
||||
name = "Test Veranstaltung",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
veranstalterName = "Test Veranstalter",
|
||||
veranstalterOepsNummer = null,
|
||||
veranstaltungsortName = "Test Ort",
|
||||
veranstaltungsortAdresse = "Test Adresse",
|
||||
kontaktpersonName = null,
|
||||
kontaktTelefon = null,
|
||||
kontaktEmail = null,
|
||||
webseite = null,
|
||||
logoUrl = null,
|
||||
anfahrtsplanInfo = null,
|
||||
dsgvoText = null,
|
||||
haftungsText = null,
|
||||
sonstigeBesondereBestimmungen = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("Test Veranstaltung", veranstaltung.name)
|
||||
assertEquals(datumVon, veranstaltung.datumVon)
|
||||
assertEquals(datumBis, veranstaltung.datumBis)
|
||||
assertEquals("Test Veranstalter", veranstaltung.veranstalterName)
|
||||
assertEquals("Test Ort", veranstaltung.veranstaltungsortName)
|
||||
assertEquals("Test Adresse", veranstaltung.veranstaltungsortAdresse)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(veranstaltung.id)
|
||||
assertEquals(VeranstalterTyp.UNBEKANNT, veranstaltung.veranstalterTyp)
|
||||
assertEquals(null, veranstaltung.veranstalterOepsNummer)
|
||||
assertEquals(null, veranstaltung.kontaktpersonName)
|
||||
assertEquals(null, veranstaltung.kontaktTelefon)
|
||||
assertEquals(null, veranstaltung.kontaktEmail)
|
||||
assertEquals(null, veranstaltung.webseite)
|
||||
assertEquals(null, veranstaltung.logoUrl)
|
||||
assertEquals(null, veranstaltung.anfahrtsplanInfo)
|
||||
assertTrue(veranstaltung.sponsorInfos.isEmpty())
|
||||
assertEquals(null, veranstaltung.dsgvoText)
|
||||
assertEquals(null, veranstaltung.haftungsText)
|
||||
assertEquals(null, veranstaltung.sonstigeBesondereBestimmungen)
|
||||
assertNotNull(veranstaltung.createdAt)
|
||||
assertNotNull(veranstaltung.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateVeranstaltungWithAllParameters() {
|
||||
// Create a Veranstaltung with all parameters
|
||||
val id = uuid4()
|
||||
val datumVon = LocalDate(2023, 7, 15)
|
||||
val datumBis = LocalDate(2023, 7, 17)
|
||||
val now = Clock.System.now()
|
||||
val sponsorInfos = listOf("Sponsor 1", "Sponsor 2")
|
||||
|
||||
val veranstaltung = Veranstaltung(
|
||||
id = id,
|
||||
name = "Vollständige Veranstaltung",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
veranstalterName = "Vollständiger Veranstalter",
|
||||
veranstalterOepsNummer = "V12345",
|
||||
veranstalterTyp = VeranstalterTyp.VEREIN,
|
||||
veranstaltungsortName = "Vollständiger Ort",
|
||||
veranstaltungsortAdresse = "Vollständige Adresse",
|
||||
kontaktpersonName = "Max Mustermann",
|
||||
kontaktTelefon = "+43 123 456789",
|
||||
kontaktEmail = "max@example.com",
|
||||
webseite = "https://example.com",
|
||||
logoUrl = "https://example.com/logo.png",
|
||||
anfahrtsplanInfo = "Anfahrtsplan Info",
|
||||
sponsorInfos = sponsorInfos,
|
||||
dsgvoText = "DSGVO Text",
|
||||
haftungsText = "Haftungs Text",
|
||||
sonstigeBesondereBestimmungen = "Besondere Bestimmungen",
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, veranstaltung.id)
|
||||
assertEquals("Vollständige Veranstaltung", veranstaltung.name)
|
||||
assertEquals(datumVon, veranstaltung.datumVon)
|
||||
assertEquals(datumBis, veranstaltung.datumBis)
|
||||
assertEquals("Vollständiger Veranstalter", veranstaltung.veranstalterName)
|
||||
assertEquals("V12345", veranstaltung.veranstalterOepsNummer)
|
||||
assertEquals(VeranstalterTyp.VEREIN, veranstaltung.veranstalterTyp)
|
||||
assertEquals("Vollständiger Ort", veranstaltung.veranstaltungsortName)
|
||||
assertEquals("Vollständige Adresse", veranstaltung.veranstaltungsortAdresse)
|
||||
assertEquals("Max Mustermann", veranstaltung.kontaktpersonName)
|
||||
assertEquals("+43 123 456789", veranstaltung.kontaktTelefon)
|
||||
assertEquals("max@example.com", veranstaltung.kontaktEmail)
|
||||
assertEquals("https://example.com", veranstaltung.webseite)
|
||||
assertEquals("https://example.com/logo.png", veranstaltung.logoUrl)
|
||||
assertEquals("Anfahrtsplan Info", veranstaltung.anfahrtsplanInfo)
|
||||
assertEquals(sponsorInfos, veranstaltung.sponsorInfos)
|
||||
assertEquals("DSGVO Text", veranstaltung.dsgvoText)
|
||||
assertEquals("Haftungs Text", veranstaltung.haftungsText)
|
||||
assertEquals("Besondere Bestimmungen", veranstaltung.sonstigeBesondereBestimmungen)
|
||||
assertEquals(now, veranstaltung.createdAt)
|
||||
assertEquals(now, veranstaltung.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyVeranstaltung() {
|
||||
// Create a Veranstaltung
|
||||
val datumVon = LocalDate(2023, 8, 1)
|
||||
val datumBis = LocalDate(2023, 8, 3)
|
||||
|
||||
val veranstaltung = Veranstaltung(
|
||||
name = "Original Veranstaltung",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
veranstalterName = "Original Veranstalter",
|
||||
veranstalterOepsNummer = null,
|
||||
veranstaltungsortName = "Original Ort",
|
||||
veranstaltungsortAdresse = "Original Adresse",
|
||||
kontaktpersonName = null,
|
||||
kontaktTelefon = null,
|
||||
kontaktEmail = null,
|
||||
webseite = null,
|
||||
logoUrl = null,
|
||||
anfahrtsplanInfo = null,
|
||||
dsgvoText = null,
|
||||
haftungsText = null,
|
||||
sonstigeBesondereBestimmungen = null
|
||||
)
|
||||
|
||||
val originalUpdatedAt = veranstaltung.updatedAt
|
||||
val newDatumVon = LocalDate(2023, 9, 1)
|
||||
val newDatumBis = LocalDate(2023, 9, 3)
|
||||
val sponsorInfos = listOf("Neuer Sponsor")
|
||||
|
||||
// Modify properties
|
||||
veranstaltung.name = "Geänderte Veranstaltung"
|
||||
veranstaltung.datumVon = newDatumVon
|
||||
veranstaltung.datumBis = newDatumBis
|
||||
veranstaltung.veranstalterName = "Geänderter Veranstalter"
|
||||
veranstaltung.veranstalterOepsNummer = "V54321"
|
||||
veranstaltung.veranstalterTyp = VeranstalterTyp.FIRMA
|
||||
veranstaltung.veranstaltungsortName = "Geänderter Ort"
|
||||
veranstaltung.veranstaltungsortAdresse = "Geänderte Adresse"
|
||||
veranstaltung.kontaktpersonName = "Maria Musterfrau"
|
||||
veranstaltung.kontaktTelefon = "+43 987 654321"
|
||||
veranstaltung.kontaktEmail = "maria@example.com"
|
||||
veranstaltung.webseite = "https://example.com/neu"
|
||||
veranstaltung.logoUrl = "https://example.com/neues-logo.png"
|
||||
veranstaltung.anfahrtsplanInfo = "Neue Anfahrtsplan Info"
|
||||
veranstaltung.sponsorInfos = sponsorInfos
|
||||
veranstaltung.dsgvoText = "Neuer DSGVO Text"
|
||||
veranstaltung.haftungsText = "Neuer Haftungs Text"
|
||||
veranstaltung.sonstigeBesondereBestimmungen = "Neue Besondere Bestimmungen"
|
||||
veranstaltung.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("Geänderte Veranstaltung", veranstaltung.name)
|
||||
assertEquals(newDatumVon, veranstaltung.datumVon)
|
||||
assertEquals(newDatumBis, veranstaltung.datumBis)
|
||||
assertEquals("Geänderter Veranstalter", veranstaltung.veranstalterName)
|
||||
assertEquals("V54321", veranstaltung.veranstalterOepsNummer)
|
||||
assertEquals(VeranstalterTyp.FIRMA, veranstaltung.veranstalterTyp)
|
||||
assertEquals("Geänderter Ort", veranstaltung.veranstaltungsortName)
|
||||
assertEquals("Geänderte Adresse", veranstaltung.veranstaltungsortAdresse)
|
||||
assertEquals("Maria Musterfrau", veranstaltung.kontaktpersonName)
|
||||
assertEquals("+43 987 654321", veranstaltung.kontaktTelefon)
|
||||
assertEquals("maria@example.com", veranstaltung.kontaktEmail)
|
||||
assertEquals("https://example.com/neu", veranstaltung.webseite)
|
||||
assertEquals("https://example.com/neues-logo.png", veranstaltung.logoUrl)
|
||||
assertEquals("Neue Anfahrtsplan Info", veranstaltung.anfahrtsplanInfo)
|
||||
assertEquals(sponsorInfos, veranstaltung.sponsorInfos)
|
||||
assertEquals("Neuer DSGVO Text", veranstaltung.dsgvoText)
|
||||
assertEquals("Neuer Haftungs Text", veranstaltung.haftungsText)
|
||||
assertEquals("Neue Besondere Bestimmungen", veranstaltung.sonstigeBesondereBestimmungen)
|
||||
assertNotEquals(originalUpdatedAt, veranstaltung.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a Veranstaltung
|
||||
val datumVon = LocalDate(2023, 10, 1)
|
||||
val datumBis = LocalDate(2023, 10, 3)
|
||||
val sponsorInfos = listOf("Sponsor A", "Sponsor B")
|
||||
|
||||
val veranstaltung = Veranstaltung(
|
||||
name = "Serialisierte Veranstaltung",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
veranstalterName = "Serialisierter Veranstalter",
|
||||
veranstalterOepsNummer = "V12345",
|
||||
veranstalterTyp = VeranstalterTyp.VEREIN,
|
||||
veranstaltungsortName = "Serialisierter Ort",
|
||||
veranstaltungsortAdresse = "Serialisierte Adresse",
|
||||
kontaktpersonName = "Kontakt Person",
|
||||
kontaktTelefon = "+43 123 456789",
|
||||
kontaktEmail = "kontakt@example.com",
|
||||
webseite = "https://example.com",
|
||||
logoUrl = "https://example.com/logo.png",
|
||||
anfahrtsplanInfo = "Anfahrtsplan Info",
|
||||
sponsorInfos = sponsorInfos,
|
||||
dsgvoText = "DSGVO Text",
|
||||
haftungsText = "Haftungs Text",
|
||||
sonstigeBesondereBestimmungen = "Besondere Bestimmungen"
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(veranstaltung)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"name\""), "JSON should contain name field")
|
||||
assertTrue(jsonString.contains("\"Serialisierte Veranstaltung\""), "JSON should contain name value")
|
||||
assertTrue(jsonString.contains("\"datumVon\""), "JSON should contain datumVon field")
|
||||
assertTrue(jsonString.contains("\"2023-10-01\""), "JSON should contain datumVon value")
|
||||
assertTrue(jsonString.contains("\"veranstalterName\""), "JSON should contain veranstalterName field")
|
||||
assertTrue(jsonString.contains("\"Serialisierter Veranstalter\""), "JSON should contain veranstalterName value")
|
||||
assertTrue(jsonString.contains("\"veranstalterTyp\""), "JSON should contain veranstalterTyp field")
|
||||
assertTrue(jsonString.contains("\"VEREIN\""), "JSON should contain veranstalterTyp value")
|
||||
assertTrue(jsonString.contains("\"sponsorInfos\""), "JSON should contain sponsorInfos field")
|
||||
assertTrue(jsonString.contains("\"Sponsor A\""), "JSON should contain sponsorInfos value")
|
||||
assertTrue(jsonString.contains("\"Sponsor B\""), "JSON should contain sponsorInfos value")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedVeranstaltung = json.decodeFromString<Veranstaltung>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(veranstaltung.id, deserializedVeranstaltung.id)
|
||||
assertEquals(veranstaltung.name, deserializedVeranstaltung.name)
|
||||
assertEquals(veranstaltung.datumVon, deserializedVeranstaltung.datumVon)
|
||||
assertEquals(veranstaltung.datumBis, deserializedVeranstaltung.datumBis)
|
||||
assertEquals(veranstaltung.veranstalterName, deserializedVeranstaltung.veranstalterName)
|
||||
assertEquals(veranstaltung.veranstalterOepsNummer, deserializedVeranstaltung.veranstalterOepsNummer)
|
||||
assertEquals(veranstaltung.veranstalterTyp, deserializedVeranstaltung.veranstalterTyp)
|
||||
assertEquals(veranstaltung.veranstaltungsortName, deserializedVeranstaltung.veranstaltungsortName)
|
||||
assertEquals(veranstaltung.veranstaltungsortAdresse, deserializedVeranstaltung.veranstaltungsortAdresse)
|
||||
assertEquals(veranstaltung.kontaktpersonName, deserializedVeranstaltung.kontaktpersonName)
|
||||
assertEquals(veranstaltung.kontaktTelefon, deserializedVeranstaltung.kontaktTelefon)
|
||||
assertEquals(veranstaltung.kontaktEmail, deserializedVeranstaltung.kontaktEmail)
|
||||
assertEquals(veranstaltung.webseite, deserializedVeranstaltung.webseite)
|
||||
assertEquals(veranstaltung.logoUrl, deserializedVeranstaltung.logoUrl)
|
||||
assertEquals(veranstaltung.anfahrtsplanInfo, deserializedVeranstaltung.anfahrtsplanInfo)
|
||||
assertEquals(veranstaltung.sponsorInfos, deserializedVeranstaltung.sponsorInfos)
|
||||
assertEquals(veranstaltung.dsgvoText, deserializedVeranstaltung.dsgvoText)
|
||||
assertEquals(veranstaltung.haftungsText, deserializedVeranstaltung.haftungsText)
|
||||
assertEquals(veranstaltung.sonstigeBesondereBestimmungen, deserializedVeranstaltung.sonstigeBesondereBestimmungen)
|
||||
assertEquals(veranstaltung.createdAt, deserializedVeranstaltung.createdAt)
|
||||
assertEquals(veranstaltung.updatedAt, deserializedVeranstaltung.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyVeranstaltung() {
|
||||
// Create a Veranstaltung
|
||||
val datumVon = LocalDate(2023, 11, 1)
|
||||
val datumBis = LocalDate(2023, 11, 3)
|
||||
|
||||
val original = Veranstaltung(
|
||||
name = "Original Veranstaltung",
|
||||
datumVon = datumVon,
|
||||
datumBis = datumBis,
|
||||
veranstalterName = "Original Veranstalter",
|
||||
veranstalterOepsNummer = "V12345",
|
||||
veranstalterTyp = VeranstalterTyp.VEREIN,
|
||||
veranstaltungsortName = "Original Ort",
|
||||
veranstaltungsortAdresse = "Original Adresse",
|
||||
kontaktpersonName = "Original Kontakt",
|
||||
kontaktTelefon = null,
|
||||
kontaktEmail = null,
|
||||
webseite = null,
|
||||
logoUrl = null,
|
||||
anfahrtsplanInfo = null,
|
||||
dsgvoText = null,
|
||||
haftungsText = null,
|
||||
sonstigeBesondereBestimmungen = null
|
||||
)
|
||||
|
||||
val newDatumVon = LocalDate(2023, 12, 1)
|
||||
val newDatumBis = LocalDate(2023, 12, 3)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
name = "Kopierte Veranstaltung",
|
||||
datumVon = newDatumVon,
|
||||
datumBis = newDatumBis,
|
||||
veranstalterTyp = VeranstalterTyp.FIRMA
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.veranstalterName, copy.veranstalterName)
|
||||
assertEquals(original.veranstalterOepsNummer, copy.veranstalterOepsNummer)
|
||||
assertEquals(original.veranstaltungsortName, copy.veranstaltungsortName)
|
||||
assertEquals(original.veranstaltungsortAdresse, copy.veranstaltungsortAdresse)
|
||||
assertEquals(original.kontaktpersonName, copy.kontaktpersonName)
|
||||
assertEquals(original.kontaktTelefon, copy.kontaktTelefon)
|
||||
assertEquals(original.kontaktEmail, copy.kontaktEmail)
|
||||
assertEquals(original.webseite, copy.webseite)
|
||||
assertEquals(original.logoUrl, copy.logoUrl)
|
||||
assertEquals(original.anfahrtsplanInfo, copy.anfahrtsplanInfo)
|
||||
assertEquals(original.sponsorInfos, copy.sponsorInfos)
|
||||
assertEquals(original.dsgvoText, copy.dsgvoText)
|
||||
assertEquals(original.haftungsText, copy.haftungsText)
|
||||
assertEquals(original.sonstigeBesondereBestimmungen, copy.sonstigeBesondereBestimmungen)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Kopierte Veranstaltung", copy.name)
|
||||
assertEquals(newDatumVon, copy.datumVon)
|
||||
assertEquals(newDatumBis, copy.datumBis)
|
||||
assertEquals(VeranstalterTyp.FIRMA, copy.veranstalterTyp)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,575 @@
|
||||
package at.mocode.shared.model.enums
|
||||
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class EnumsTest {
|
||||
|
||||
@Test
|
||||
fun testVeranstalterTypEnum() {
|
||||
// Test all enum values
|
||||
val values = VeranstalterTyp.entries.toTypedArray()
|
||||
assertEquals(5, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(VeranstalterTyp.VEREIN, values[0])
|
||||
assertEquals(VeranstalterTyp.FIRMA, values[1])
|
||||
assertEquals(VeranstalterTyp.PRIVATPERSON, values[2])
|
||||
assertEquals(VeranstalterTyp.SONSTIGE, values[3])
|
||||
assertEquals(VeranstalterTyp.UNBEKANNT, values[4])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(VeranstalterTyp.VEREIN)
|
||||
testEnumSerialization(VeranstalterTyp.FIRMA)
|
||||
testEnumSerialization(VeranstalterTyp.PRIVATPERSON)
|
||||
testEnumSerialization(VeranstalterTyp.SONSTIGE)
|
||||
testEnumSerialization(VeranstalterTyp.UNBEKANNT)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(VeranstalterTyp.VEREIN, VeranstalterTyp.VEREIN)
|
||||
assertNotEquals(VeranstalterTyp.VEREIN, VeranstalterTyp.FIRMA)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPlatzTypEnum() {
|
||||
// Test all enum values
|
||||
val values = PlatzTyp.entries.toTypedArray()
|
||||
assertEquals(4, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(PlatzTyp.AUSTRAGUNG, values[0])
|
||||
assertEquals(PlatzTyp.VORBEREITUNG, values[1])
|
||||
assertEquals(PlatzTyp.LONGIEREN, values[2])
|
||||
assertEquals(PlatzTyp.SONSTIGES, values[3])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(PlatzTyp.AUSTRAGUNG)
|
||||
testEnumSerialization(PlatzTyp.VORBEREITUNG)
|
||||
testEnumSerialization(PlatzTyp.LONGIEREN)
|
||||
testEnumSerialization(PlatzTyp.SONSTIGES)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(PlatzTyp.AUSTRAGUNG, PlatzTyp.AUSTRAGUNG)
|
||||
assertNotEquals(PlatzTyp.AUSTRAGUNG, PlatzTyp.VORBEREITUNG)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testNennungsArtEnum() {
|
||||
// Test all enum values
|
||||
val values = NennungsArt.entries.toTypedArray()
|
||||
assertEquals(6, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(NennungsArt.OEPS_ZNS, values[0])
|
||||
assertEquals(NennungsArt.EIGENES_ONLINE, values[1])
|
||||
assertEquals(NennungsArt.DIREKT_VERANSTALTER_EMAIL, values[2])
|
||||
assertEquals(NennungsArt.DIREKT_VERANSTALTER_TELEFON, values[3])
|
||||
assertEquals(NennungsArt.DIREKT_VERANSTALTER_WHATSAPP, values[4])
|
||||
assertEquals(NennungsArt.SONSTIGE, values[5])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(NennungsArt.OEPS_ZNS)
|
||||
testEnumSerialization(NennungsArt.EIGENES_ONLINE)
|
||||
testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_EMAIL)
|
||||
testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_TELEFON)
|
||||
testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_WHATSAPP)
|
||||
testEnumSerialization(NennungsArt.SONSTIGE)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(NennungsArt.OEPS_ZNS, NennungsArt.OEPS_ZNS)
|
||||
assertNotEquals(NennungsArt.OEPS_ZNS, NennungsArt.EIGENES_ONLINE)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSparteEnum() {
|
||||
// Test all enum values
|
||||
val values = Sparte.entries.toTypedArray()
|
||||
assertEquals(12, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(Sparte.DRESSUR, values[0])
|
||||
assertEquals(Sparte.SPRINGEN, values[1])
|
||||
assertEquals(Sparte.VIELSEITIGKEIT, values[2])
|
||||
assertEquals(Sparte.FAHREN, values[3])
|
||||
assertEquals(Sparte.VOLTIGIEREN, values[4])
|
||||
assertEquals(Sparte.WESTERN, values[5])
|
||||
assertEquals(Sparte.DISTANZ, values[6])
|
||||
assertEquals(Sparte.ISLAND, values[7])
|
||||
assertEquals(Sparte.PFERDESPORT_SPIEL, values[8])
|
||||
assertEquals(Sparte.BASIS, values[9])
|
||||
assertEquals(Sparte.KOMBINIERT, values[10])
|
||||
assertEquals(Sparte.SONSTIGES, values[11])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(Sparte.DRESSUR)
|
||||
testEnumSerialization(Sparte.SPRINGEN)
|
||||
testEnumSerialization(Sparte.VIELSEITIGKEIT)
|
||||
testEnumSerialization(Sparte.FAHREN)
|
||||
testEnumSerialization(Sparte.VOLTIGIEREN)
|
||||
testEnumSerialization(Sparte.WESTERN)
|
||||
testEnumSerialization(Sparte.DISTANZ)
|
||||
testEnumSerialization(Sparte.ISLAND)
|
||||
testEnumSerialization(Sparte.PFERDESPORT_SPIEL)
|
||||
testEnumSerialization(Sparte.BASIS)
|
||||
testEnumSerialization(Sparte.KOMBINIERT)
|
||||
testEnumSerialization(Sparte.SONSTIGES)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(Sparte.DRESSUR, Sparte.DRESSUR)
|
||||
assertNotEquals(Sparte.DRESSUR, Sparte.SPRINGEN)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBewerbStatusEnum() {
|
||||
// Test all enum values
|
||||
val values = BewerbStatus.entries.toTypedArray()
|
||||
assertEquals(6, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(BewerbStatus.GEPLANT, values[0])
|
||||
assertEquals(BewerbStatus.OFFEN_FUER_NENNUNG, values[1])
|
||||
assertEquals(BewerbStatus.GESCHLOSSEN_FUER_NENNUNG, values[2])
|
||||
assertEquals(BewerbStatus.LAEUFT, values[3])
|
||||
assertEquals(BewerbStatus.ABGESCHLOSSEN, values[4])
|
||||
assertEquals(BewerbStatus.ABGESAGT, values[5])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(BewerbStatus.GEPLANT)
|
||||
testEnumSerialization(BewerbStatus.OFFEN_FUER_NENNUNG)
|
||||
testEnumSerialization(BewerbStatus.GESCHLOSSEN_FUER_NENNUNG)
|
||||
testEnumSerialization(BewerbStatus.LAEUFT)
|
||||
testEnumSerialization(BewerbStatus.ABGESCHLOSSEN)
|
||||
testEnumSerialization(BewerbStatus.ABGESAGT)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(BewerbStatus.GEPLANT, BewerbStatus.GEPLANT)
|
||||
assertNotEquals(BewerbStatus.GEPLANT, BewerbStatus.ABGESAGT)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBedingungstypEnum() {
|
||||
// Test all enum values
|
||||
val values = Bedingungstyp.entries.toTypedArray()
|
||||
assertEquals(9, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(Bedingungstyp.LIZENZ_REITER, values[0])
|
||||
assertEquals(Bedingungstyp.LIZENZ_FAHRER, values[1])
|
||||
assertEquals(Bedingungstyp.ALTER_PFERD, values[2])
|
||||
assertEquals(Bedingungstyp.ALTER_REITER, values[3])
|
||||
assertEquals(Bedingungstyp.RASSE_PFERD, values[4])
|
||||
assertEquals(Bedingungstyp.GESCHLECHT_PFERD, values[5])
|
||||
assertEquals(Bedingungstyp.GESCHLECHT_REITER, values[6])
|
||||
assertEquals(Bedingungstyp.STARTKARTE, values[7])
|
||||
assertEquals(Bedingungstyp.SONSTIGES, values[8])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(Bedingungstyp.LIZENZ_REITER)
|
||||
testEnumSerialization(Bedingungstyp.LIZENZ_FAHRER)
|
||||
testEnumSerialization(Bedingungstyp.ALTER_PFERD)
|
||||
testEnumSerialization(Bedingungstyp.ALTER_REITER)
|
||||
testEnumSerialization(Bedingungstyp.RASSE_PFERD)
|
||||
testEnumSerialization(Bedingungstyp.GESCHLECHT_PFERD)
|
||||
testEnumSerialization(Bedingungstyp.GESCHLECHT_REITER)
|
||||
testEnumSerialization(Bedingungstyp.STARTKARTE)
|
||||
testEnumSerialization(Bedingungstyp.SONSTIGES)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(Bedingungstyp.LIZENZ_REITER, Bedingungstyp.LIZENZ_REITER)
|
||||
assertNotEquals(Bedingungstyp.LIZENZ_REITER, Bedingungstyp.LIZENZ_FAHRER)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testOperatorEnum() {
|
||||
// Test all enum values
|
||||
val values = Operator.entries.toTypedArray()
|
||||
assertEquals(7, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(Operator.GLEICH, values[0])
|
||||
assertEquals(Operator.UNGLEICH, values[1])
|
||||
assertEquals(Operator.MINDESTENS, values[2])
|
||||
assertEquals(Operator.MAXIMAL, values[3])
|
||||
assertEquals(Operator.ZWISCHEN, values[4])
|
||||
assertEquals(Operator.IN_LISTE, values[5])
|
||||
assertEquals(Operator.NICHT_IN_LISTE, values[6])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(Operator.GLEICH)
|
||||
testEnumSerialization(Operator.UNGLEICH)
|
||||
testEnumSerialization(Operator.MINDESTENS)
|
||||
testEnumSerialization(Operator.MAXIMAL)
|
||||
testEnumSerialization(Operator.ZWISCHEN)
|
||||
testEnumSerialization(Operator.IN_LISTE)
|
||||
testEnumSerialization(Operator.NICHT_IN_LISTE)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(Operator.GLEICH, Operator.GLEICH)
|
||||
assertNotEquals(Operator.GLEICH, Operator.UNGLEICH)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testFunktionaerRolleEnum() {
|
||||
// Test all enum values
|
||||
val values = FunktionaerRolle.entries.toTypedArray()
|
||||
assertEquals(12, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(FunktionaerRolle.RICHTER, values[0])
|
||||
assertEquals(FunktionaerRolle.PARCOURSBAUER, values[1])
|
||||
assertEquals(FunktionaerRolle.PARCOURSBAU_ASSISTENT, values[2])
|
||||
assertEquals(FunktionaerRolle.TECHN_DELEGIERTER, values[3])
|
||||
assertEquals(FunktionaerRolle.TURNIERBEAUFTRAGTER, values[4])
|
||||
assertEquals(FunktionaerRolle.STEWARD, values[5])
|
||||
assertEquals(FunktionaerRolle.ZEITNEHMER, values[6])
|
||||
assertEquals(FunktionaerRolle.SCHREIBER, values[7])
|
||||
assertEquals(FunktionaerRolle.VERANSTALTER_KONTAKT, values[8])
|
||||
assertEquals(FunktionaerRolle.TURNIERLEITER, values[9])
|
||||
assertEquals(FunktionaerRolle.HELFER, values[10])
|
||||
assertEquals(FunktionaerRolle.SONSTIGE, values[11])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(FunktionaerRolle.RICHTER)
|
||||
testEnumSerialization(FunktionaerRolle.PARCOURSBAUER)
|
||||
testEnumSerialization(FunktionaerRolle.PARCOURSBAU_ASSISTENT)
|
||||
testEnumSerialization(FunktionaerRolle.TECHN_DELEGIERTER)
|
||||
testEnumSerialization(FunktionaerRolle.TURNIERBEAUFTRAGTER)
|
||||
testEnumSerialization(FunktionaerRolle.STEWARD)
|
||||
testEnumSerialization(FunktionaerRolle.ZEITNEHMER)
|
||||
testEnumSerialization(FunktionaerRolle.SCHREIBER)
|
||||
testEnumSerialization(FunktionaerRolle.VERANSTALTER_KONTAKT)
|
||||
testEnumSerialization(FunktionaerRolle.TURNIERLEITER)
|
||||
testEnumSerialization(FunktionaerRolle.HELFER)
|
||||
testEnumSerialization(FunktionaerRolle.SONSTIGE)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(FunktionaerRolle.RICHTER, FunktionaerRolle.RICHTER)
|
||||
assertNotEquals(FunktionaerRolle.RICHTER, FunktionaerRolle.PARCOURSBAUER)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testRichterPositionEnum() {
|
||||
// Test all enum values
|
||||
val values = RichterPosition.entries.toTypedArray()
|
||||
assertEquals(8, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(RichterPosition.BEI_C, values[0])
|
||||
assertEquals(RichterPosition.BEI_E, values[1])
|
||||
assertEquals(RichterPosition.BEI_H, values[2])
|
||||
assertEquals(RichterPosition.BEI_M, values[3])
|
||||
assertEquals(RichterPosition.BEI_B, values[4])
|
||||
assertEquals(RichterPosition.VORSITZ, values[5])
|
||||
assertEquals(RichterPosition.SEITENRICHTER, values[6])
|
||||
assertEquals(RichterPosition.SONSTIGE, values[7])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(RichterPosition.BEI_C)
|
||||
testEnumSerialization(RichterPosition.BEI_E)
|
||||
testEnumSerialization(RichterPosition.BEI_H)
|
||||
testEnumSerialization(RichterPosition.BEI_M)
|
||||
testEnumSerialization(RichterPosition.BEI_B)
|
||||
testEnumSerialization(RichterPosition.VORSITZ)
|
||||
testEnumSerialization(RichterPosition.SEITENRICHTER)
|
||||
testEnumSerialization(RichterPosition.SONSTIGE)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(RichterPosition.BEI_C, RichterPosition.BEI_C)
|
||||
assertNotEquals(RichterPosition.BEI_C, RichterPosition.BEI_E)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testGeschlechtEnum() {
|
||||
// Test all enum values
|
||||
val values = Geschlecht.entries.toTypedArray()
|
||||
assertEquals(4, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(Geschlecht.M, values[0])
|
||||
assertEquals(Geschlecht.W, values[1])
|
||||
assertEquals(Geschlecht.D, values[2])
|
||||
assertEquals(Geschlecht.UNBEKANNT, values[3])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(Geschlecht.M)
|
||||
testEnumSerialization(Geschlecht.W)
|
||||
testEnumSerialization(Geschlecht.D)
|
||||
testEnumSerialization(Geschlecht.UNBEKANNT)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(Geschlecht.M, Geschlecht.M)
|
||||
assertNotEquals(Geschlecht.M, Geschlecht.W)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testLizenzTypEnum() {
|
||||
// Test all enum values
|
||||
val values = LizenzTyp.entries.toTypedArray()
|
||||
assertEquals(15, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(LizenzTyp.REITER, values[0])
|
||||
assertEquals(LizenzTyp.FAHRER, values[1])
|
||||
assertEquals(LizenzTyp.VOLTIGIERER, values[2])
|
||||
assertEquals(LizenzTyp.WESTERN, values[3])
|
||||
assertEquals(LizenzTyp.WORKING_EQUITATION, values[4])
|
||||
assertEquals(LizenzTyp.POLO, values[5])
|
||||
assertEquals(LizenzTyp.STARTKARTE_ALLG, values[6])
|
||||
assertEquals(LizenzTyp.STARTKARTE_VOLTIGIEREN, values[7])
|
||||
assertEquals(LizenzTyp.STARTKARTE_WESTERN, values[8])
|
||||
assertEquals(LizenzTyp.STARTKARTE_ISLAND, values[9])
|
||||
assertEquals(LizenzTyp.STARTKARTE_FAHREN_JUGEND, values[10])
|
||||
assertEquals(LizenzTyp.STARTKARTE_HORSEBALL, values[11])
|
||||
assertEquals(LizenzTyp.STARTKARTE_POLO, values[12])
|
||||
assertEquals(LizenzTyp.PARAEQUESTRIAN, values[13])
|
||||
assertEquals(LizenzTyp.SONSTIGE, values[14])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(LizenzTyp.REITER)
|
||||
testEnumSerialization(LizenzTyp.FAHRER)
|
||||
testEnumSerialization(LizenzTyp.VOLTIGIERER)
|
||||
testEnumSerialization(LizenzTyp.WESTERN)
|
||||
testEnumSerialization(LizenzTyp.WORKING_EQUITATION)
|
||||
testEnumSerialization(LizenzTyp.POLO)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_ALLG)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_VOLTIGIEREN)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_WESTERN)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_ISLAND)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_FAHREN_JUGEND)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_HORSEBALL)
|
||||
testEnumSerialization(LizenzTyp.STARTKARTE_POLO)
|
||||
testEnumSerialization(LizenzTyp.PARAEQUESTRIAN)
|
||||
testEnumSerialization(LizenzTyp.SONSTIGE)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(LizenzTyp.REITER, LizenzTyp.REITER)
|
||||
assertNotEquals(LizenzTyp.REITER, LizenzTyp.FAHRER)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testGeschlechtPferdEnum() {
|
||||
// Test all enum values
|
||||
val values = GeschlechtPferd.entries.toTypedArray()
|
||||
assertEquals(4, values.size)
|
||||
|
||||
// Test specific enum values
|
||||
assertEquals(GeschlechtPferd.HENGST, values[0])
|
||||
assertEquals(GeschlechtPferd.STUTE, values[1])
|
||||
assertEquals(GeschlechtPferd.WALLACH, values[2])
|
||||
assertEquals(GeschlechtPferd.UNBEKANNT, values[3])
|
||||
|
||||
// Test serialization and deserialization
|
||||
testEnumSerialization(GeschlechtPferd.HENGST)
|
||||
testEnumSerialization(GeschlechtPferd.STUTE)
|
||||
testEnumSerialization(GeschlechtPferd.WALLACH)
|
||||
testEnumSerialization(GeschlechtPferd.UNBEKANNT)
|
||||
|
||||
// Test comparison
|
||||
assertEquals(GeschlechtPferd.HENGST, GeschlechtPferd.HENGST)
|
||||
assertNotEquals(GeschlechtPferd.HENGST, GeschlechtPferd.STUTE)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testEnumCollections() {
|
||||
// Test using enums in collections
|
||||
val enumSet = setOf(
|
||||
Geschlecht.M,
|
||||
Geschlecht.W,
|
||||
FunktionaerRolle.RICHTER,
|
||||
FunktionaerRolle.PARCOURSBAUER
|
||||
)
|
||||
|
||||
assertTrue(enumSet.contains(Geschlecht.M))
|
||||
assertTrue(enumSet.contains(FunktionaerRolle.RICHTER))
|
||||
assertEquals(4, enumSet.size)
|
||||
|
||||
// Test serialization of collections with enums
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
val geschlecht: Geschlecht,
|
||||
val rollen: Set<FunktionaerRolle>
|
||||
)
|
||||
|
||||
val testObject = TestClass(
|
||||
geschlecht = Geschlecht.M,
|
||||
rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.PARCOURSBAUER)
|
||||
)
|
||||
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"geschlecht\""))
|
||||
assertTrue(jsonString.contains("\"M\""))
|
||||
assertTrue(jsonString.contains("\"rollen\""))
|
||||
assertTrue(jsonString.contains("\"RICHTER\""))
|
||||
assertTrue(jsonString.contains("\"PARCOURSBAUER\""))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(testObject.geschlecht, deserializedObject.geschlecht)
|
||||
assertEquals(testObject.rollen, deserializedObject.rollen)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: VeranstalterTyp) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<VeranstalterTyp>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: PlatzTyp) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<PlatzTyp>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: NennungsArt) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<NennungsArt>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: Sparte) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<Sparte>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: BewerbStatus) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<BewerbStatus>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: Bedingungstyp) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<Bedingungstyp>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: Operator) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<Operator>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: FunktionaerRolle) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<FunktionaerRolle>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: RichterPosition) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<RichterPosition>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: Geschlecht) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<Geschlecht>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: LizenzTyp) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<LizenzTyp>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
|
||||
// Test serialization for a specific enum value
|
||||
private fun testEnumSerialization(value: GeschlechtPferd) {
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(value)
|
||||
|
||||
// Verify serialization
|
||||
assertEquals("\"${value.name}\"", jsonString)
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedValue = json.decodeFromString<GeschlechtPferd>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
package at.mocode.shared.model.serializers
|
||||
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import com.benasher44.uuid.uuidFrom
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.datetime.LocalDateTime
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class SerializationTest {
|
||||
|
||||
@Test
|
||||
fun testBigDecimalSerializer() {
|
||||
// Test regular values
|
||||
testBigDecimalSerialization(BigDecimal.fromInt(0))
|
||||
testBigDecimalSerialization(BigDecimal.fromInt(42))
|
||||
testBigDecimalSerialization(BigDecimal.fromInt(-42))
|
||||
testBigDecimalSerialization(BigDecimal.parseString("123.456"))
|
||||
testBigDecimalSerialization(BigDecimal.parseString("-123.456"))
|
||||
|
||||
// Test edge cases
|
||||
testBigDecimalSerialization(BigDecimal.fromInt(Int.MAX_VALUE))
|
||||
testBigDecimalSerialization(BigDecimal.fromInt(Int.MIN_VALUE))
|
||||
testBigDecimalSerialization(BigDecimal.parseString("9999999999999999999.9999999999"))
|
||||
testBigDecimalSerialization(BigDecimal.parseString("-9999999999999999999.9999999999"))
|
||||
}
|
||||
|
||||
private fun testBigDecimalSerialization(value: BigDecimal) {
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
@Serializable(with = BigDecimalSerializer::class)
|
||||
val value: BigDecimal
|
||||
)
|
||||
|
||||
val testObject = TestClass(value)
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"value\""))
|
||||
assertTrue(jsonString.contains(value.toStringExpanded()))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(value, deserializedObject.value)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testUuidSerializer() {
|
||||
// Test regular UUIDs
|
||||
testUuidSerialization(uuid4())
|
||||
testUuidSerialization(uuidFrom("00000000-0000-0000-0000-000000000000"))
|
||||
testUuidSerialization(uuidFrom("ffffffff-ffff-ffff-ffff-ffffffffffff"))
|
||||
|
||||
// Test specific UUID formats
|
||||
testUuidSerialization(uuidFrom("12345678-1234-5678-1234-567812345678"))
|
||||
}
|
||||
|
||||
private fun testUuidSerialization(value: Uuid) {
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
val id: Uuid
|
||||
)
|
||||
|
||||
val testObject = TestClass(value)
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"id\""))
|
||||
assertTrue(jsonString.contains(value.toString()))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(value, deserializedObject.id)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testKotlinInstantSerializer() {
|
||||
// Test current time
|
||||
testInstantSerialization(Clock.System.now())
|
||||
|
||||
// Test specific instants
|
||||
testInstantSerialization(Instant.parse("2023-01-01T00:00:00Z"))
|
||||
testInstantSerialization(Instant.parse("1970-01-01T00:00:00Z"))
|
||||
testInstantSerialization(Instant.parse("2099-12-31T23:59:59.999Z"))
|
||||
|
||||
// Test with different time zones
|
||||
testInstantSerialization(Instant.parse("2023-06-15T12:30:45.123+02:00"))
|
||||
}
|
||||
|
||||
private fun testInstantSerialization(value: Instant) {
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
@Serializable(with = KotlinInstantSerializer::class)
|
||||
val timestamp: Instant
|
||||
)
|
||||
|
||||
val testObject = TestClass(value)
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"timestamp\""))
|
||||
assertTrue(jsonString.contains(value.toString()))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(value, deserializedObject.timestamp)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testKotlinLocalDateSerializer() {
|
||||
// Test regular dates
|
||||
testLocalDateSerialization(LocalDate(2023, 1, 1))
|
||||
testLocalDateSerialization(LocalDate(2000, 2, 29)) // Leap year
|
||||
testLocalDateSerialization(LocalDate(1970, 1, 1))
|
||||
|
||||
// Test edge cases
|
||||
testLocalDateSerialization(LocalDate(1, 1, 1))
|
||||
testLocalDateSerialization(LocalDate(9999, 12, 31))
|
||||
}
|
||||
|
||||
private fun testLocalDateSerialization(value: LocalDate) {
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
@Serializable(with = KotlinLocalDateSerializer::class)
|
||||
val date: LocalDate
|
||||
)
|
||||
|
||||
val testObject = TestClass(value)
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"date\""))
|
||||
assertTrue(jsonString.contains(value.toString()))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(value, deserializedObject.date)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testKotlinLocalDateTimeSerializer() {
|
||||
// Test regular date-times
|
||||
testLocalDateTimeSerialization(LocalDateTime(2023, 1, 1, 12, 0, 0))
|
||||
testLocalDateTimeSerialization(LocalDateTime(2000, 2, 29, 23, 59, 59)) // Leap year
|
||||
testLocalDateTimeSerialization(LocalDateTime(1970, 1, 1, 0, 0, 0))
|
||||
|
||||
// Test with nanoseconds
|
||||
testLocalDateTimeSerialization(LocalDateTime(2023, 6, 15, 12, 30, 45, 123456789))
|
||||
|
||||
// Test edge cases
|
||||
testLocalDateTimeSerialization(LocalDateTime(1, 1, 1, 0, 0, 0))
|
||||
testLocalDateTimeSerialization(LocalDateTime(9999, 12, 31, 23, 59, 59, 999999999))
|
||||
}
|
||||
|
||||
private fun testLocalDateTimeSerialization(value: LocalDateTime) {
|
||||
@Serializable
|
||||
data class TestClass(
|
||||
@Serializable(with = KotlinLocalDateTimeSerializer::class)
|
||||
val dateTime: LocalDateTime
|
||||
)
|
||||
|
||||
val testObject = TestClass(value)
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(testObject)
|
||||
|
||||
// Verify serialization
|
||||
assertTrue(jsonString.contains("\"dateTime\""))
|
||||
assertTrue(jsonString.contains(value.toString()))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObject = json.decodeFromString<TestClass>(jsonString)
|
||||
assertEquals(value, deserializedObject.dateTime)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testAllSerializersInSingleObject() {
|
||||
@Serializable
|
||||
data class ComplexObject(
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
val id: Uuid,
|
||||
@Serializable(with = BigDecimalSerializer::class)
|
||||
val amount: BigDecimal,
|
||||
@Serializable(with = KotlinInstantSerializer::class)
|
||||
val createdAt: Instant,
|
||||
@Serializable(with = KotlinLocalDateSerializer::class)
|
||||
val date: LocalDate,
|
||||
@Serializable(with = KotlinLocalDateTimeSerializer::class)
|
||||
val dateTime: LocalDateTime
|
||||
)
|
||||
|
||||
val obj = ComplexObject(
|
||||
id = uuid4(),
|
||||
amount = BigDecimal.parseString("123.456"),
|
||||
createdAt = Clock.System.now(),
|
||||
date = LocalDate(2023, 1, 1),
|
||||
dateTime = LocalDateTime(2023, 1, 1, 12, 0, 0)
|
||||
)
|
||||
|
||||
val json = Json { prettyPrint = true }
|
||||
val jsonString = json.encodeToString(obj)
|
||||
|
||||
// Verify serialization contains all fields
|
||||
assertTrue(jsonString.contains("\"id\""))
|
||||
assertTrue(jsonString.contains("\"amount\""))
|
||||
assertTrue(jsonString.contains("\"createdAt\""))
|
||||
assertTrue(jsonString.contains("\"date\""))
|
||||
assertTrue(jsonString.contains("\"dateTime\""))
|
||||
|
||||
// Verify deserialization
|
||||
val deserializedObj = json.decodeFromString<ComplexObject>(jsonString)
|
||||
assertEquals(obj.id, deserializedObj.id)
|
||||
assertEquals(obj.amount, deserializedObj.amount)
|
||||
assertEquals(obj.createdAt, deserializedObj.createdAt)
|
||||
assertEquals(obj.date, deserializedObj.date)
|
||||
assertEquals(obj.dateTime, deserializedObj.dateTime)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.shared.model.enums.LizenzTyp
|
||||
import at.mocode.shared.model.enums.Sparte
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class LizenzInfoTest {
|
||||
|
||||
@Test
|
||||
fun testCreateLizenzInfoWithMinimalParameters() {
|
||||
// Create a LizenzInfo with minimal required parameters
|
||||
val lizenzInfo = LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.REITER,
|
||||
stufe = null,
|
||||
sparte = null,
|
||||
gueltigBisJahr = null,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals(LizenzTyp.REITER, lizenzInfo.lizenzTyp)
|
||||
|
||||
// Verify optional fields are null
|
||||
assertEquals(null, lizenzInfo.stufe)
|
||||
assertEquals(null, lizenzInfo.sparte)
|
||||
assertEquals(null, lizenzInfo.gueltigBisJahr)
|
||||
assertEquals(null, lizenzInfo.ausgestelltAm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateLizenzInfoWithAllParameters() {
|
||||
// Create a LizenzInfo with all parameters
|
||||
val ausgestelltAm = LocalDate(2023, 1, 15)
|
||||
|
||||
val lizenzInfo = LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.FAHRER,
|
||||
stufe = "A",
|
||||
sparte = Sparte.DRESSUR,
|
||||
gueltigBisJahr = 2024,
|
||||
ausgestelltAm = ausgestelltAm
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(LizenzTyp.FAHRER, lizenzInfo.lizenzTyp)
|
||||
assertEquals("A", lizenzInfo.stufe)
|
||||
assertEquals(Sparte.DRESSUR, lizenzInfo.sparte)
|
||||
assertEquals(2024, lizenzInfo.gueltigBisJahr)
|
||||
assertEquals(ausgestelltAm, lizenzInfo.ausgestelltAm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a LizenzInfo with all parameters
|
||||
val ausgestelltAm = LocalDate(2023, 5, 20)
|
||||
|
||||
val lizenzInfo = LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.VOLTIGIERER,
|
||||
stufe = "B",
|
||||
sparte = Sparte.VOLTIGIEREN,
|
||||
gueltigBisJahr = 2025,
|
||||
ausgestelltAm = ausgestelltAm
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(lizenzInfo)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"lizenzTyp\""), "JSON should contain lizenzTyp field")
|
||||
assertTrue(jsonString.contains("\"VOLTIGIERER\""), "JSON should contain value VOLTIGIERER")
|
||||
assertTrue(jsonString.contains("\"stufe\""), "JSON should contain stufe field")
|
||||
assertTrue(jsonString.contains("\"B\""), "JSON should contain value B")
|
||||
assertTrue(jsonString.contains("\"sparte\""), "JSON should contain sparte field")
|
||||
assertTrue(jsonString.contains("\"VOLTIGIEREN\""), "JSON should contain value VOLTIGIEREN")
|
||||
assertTrue(jsonString.contains("\"gueltigBisJahr\""), "JSON should contain gueltigBisJahr field")
|
||||
assertTrue(jsonString.contains("2025"), "JSON should contain value 2025")
|
||||
assertTrue(jsonString.contains("\"ausgestelltAm\""), "JSON should contain ausgestelltAm field")
|
||||
assertTrue(jsonString.contains("2023-05-20"), "JSON should contain value 2023-05-20")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedLizenzInfo = json.decodeFromString<LizenzInfo>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(lizenzInfo.lizenzTyp, deserializedLizenzInfo.lizenzTyp)
|
||||
assertEquals(lizenzInfo.stufe, deserializedLizenzInfo.stufe)
|
||||
assertEquals(lizenzInfo.sparte, deserializedLizenzInfo.sparte)
|
||||
assertEquals(lizenzInfo.gueltigBisJahr, deserializedLizenzInfo.gueltigBisJahr)
|
||||
assertEquals(lizenzInfo.ausgestelltAm, deserializedLizenzInfo.ausgestelltAm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyLizenzInfo() {
|
||||
// Create a LizenzInfo
|
||||
val original = LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.WESTERN,
|
||||
stufe = "C",
|
||||
sparte = Sparte.WESTERN,
|
||||
gueltigBisJahr = 2023,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
stufe = "B",
|
||||
gueltigBisJahr = 2024,
|
||||
ausgestelltAm = LocalDate(2023, 12, 1)
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.lizenzTyp, copy.lizenzTyp)
|
||||
assertEquals(original.sparte, copy.sparte)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("B", copy.stufe)
|
||||
assertEquals(2024, copy.gueltigBisJahr)
|
||||
assertEquals(LocalDate(2023, 12, 1), copy.ausgestelltAm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testDifferentLizenzTypes() {
|
||||
// Test different LizenzTyp values
|
||||
val lizenzTypes = listOf(
|
||||
LizenzTyp.REITER,
|
||||
LizenzTyp.FAHRER,
|
||||
LizenzTyp.VOLTIGIERER,
|
||||
LizenzTyp.WESTERN,
|
||||
LizenzTyp.WORKING_EQUITATION,
|
||||
LizenzTyp.POLO,
|
||||
LizenzTyp.STARTKARTE_ALLG,
|
||||
LizenzTyp.STARTKARTE_VOLTIGIEREN,
|
||||
LizenzTyp.STARTKARTE_WESTERN,
|
||||
LizenzTyp.STARTKARTE_ISLAND,
|
||||
LizenzTyp.STARTKARTE_FAHREN_JUGEND,
|
||||
LizenzTyp.STARTKARTE_HORSEBALL,
|
||||
LizenzTyp.STARTKARTE_POLO,
|
||||
LizenzTyp.PARAEQUESTRIAN,
|
||||
LizenzTyp.SONSTIGE
|
||||
)
|
||||
|
||||
for (lizenzTyp in lizenzTypes) {
|
||||
val lizenzInfo = LizenzInfo(
|
||||
lizenzTyp = lizenzTyp,
|
||||
stufe = "Test",
|
||||
sparte = Sparte.SONSTIGES,
|
||||
gueltigBisJahr = 2024,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
|
||||
assertEquals(lizenzTyp, lizenzInfo.lizenzTyp)
|
||||
|
||||
// Serialize and deserialize to verify enum handling
|
||||
val json = Json { encodeDefaults = true }
|
||||
val jsonString = json.encodeToString(lizenzInfo)
|
||||
val deserializedLizenzInfo = json.decodeFromString<LizenzInfo>(jsonString)
|
||||
|
||||
assertEquals(lizenzTyp, deserializedLizenzInfo.lizenzTyp)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,393 @@
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.shared.model.enums.FunktionaerRolle
|
||||
import at.mocode.shared.model.enums.Geschlecht
|
||||
import at.mocode.shared.model.enums.LizenzTyp
|
||||
import at.mocode.shared.model.enums.Sparte
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.KotlinLocalDateSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class PersonTest {
|
||||
|
||||
@Test
|
||||
fun testCreatePerson() {
|
||||
// Create a Person with minimal required parameters
|
||||
val person = Person(
|
||||
oepsSatzNr = null,
|
||||
nachname = "Mustermann",
|
||||
vorname = "Max",
|
||||
titel = null,
|
||||
geburtsdatum = null,
|
||||
geschlecht = null,
|
||||
nationalitaet = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
stammVereinId = null,
|
||||
mitgliedsNummerIntern = null,
|
||||
letzteZahlungJahr = null,
|
||||
feiId = null,
|
||||
sperrGrund = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("Mustermann", person.nachname)
|
||||
assertEquals("Max", person.vorname)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(person.id)
|
||||
assertEquals(null, person.geschlecht)
|
||||
assertEquals(false, person.istGesperrt)
|
||||
assertTrue(person.rollen.isEmpty())
|
||||
assertTrue(person.lizenzen.isEmpty())
|
||||
assertTrue(person.qualifikationenRichter.isEmpty())
|
||||
assertTrue(person.qualifikationenParcoursbauer.isEmpty())
|
||||
assertTrue(person.istAktiv)
|
||||
assertNotNull(person.createdAt)
|
||||
assertNotNull(person.updatedAt)
|
||||
|
||||
// Verify optional fields are null
|
||||
assertEquals(null, person.oepsSatzNr)
|
||||
assertEquals(null, person.titel)
|
||||
assertEquals(null, person.geburtsdatum)
|
||||
assertEquals(null, person.nationalitaet)
|
||||
assertEquals(null, person.email)
|
||||
assertEquals(null, person.telefon)
|
||||
assertEquals(null, person.adresse)
|
||||
assertEquals(null, person.plz)
|
||||
assertEquals(null, person.ort)
|
||||
assertEquals(null, person.stammVereinId)
|
||||
assertEquals(null, person.mitgliedsNummerIntern)
|
||||
assertEquals(null, person.letzteZahlungJahr)
|
||||
assertEquals(null, person.feiId)
|
||||
assertEquals(null, person.sperrGrund)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreatePersonWithAllParameters() {
|
||||
// Create a Person with all parameters
|
||||
val id = uuid4()
|
||||
val stammVereinId = uuid4()
|
||||
val now = Clock.System.now()
|
||||
val geburtsdatum = LocalDate(1990, 1, 15)
|
||||
val rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.TURNIERLEITER)
|
||||
val lizenzen = listOf(
|
||||
LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.REITER,
|
||||
stufe = "A",
|
||||
sparte = Sparte.SPRINGEN,
|
||||
gueltigBisJahr = 2024,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
)
|
||||
val qualifikationenRichter = listOf("Springen A", "Dressur B")
|
||||
val qualifikationenParcoursbauer = listOf("Springen A")
|
||||
|
||||
val person = Person(
|
||||
id = id,
|
||||
oepsSatzNr = "12345",
|
||||
nachname = "Vollständig",
|
||||
vorname = "Victoria",
|
||||
titel = "Dr.",
|
||||
geburtsdatum = geburtsdatum,
|
||||
geschlecht = Geschlecht.W,
|
||||
nationalitaet = "AUT",
|
||||
email = "victoria@example.com",
|
||||
telefon = "+43 123 456789",
|
||||
adresse = "Musterstraße 1",
|
||||
plz = "1010",
|
||||
ort = "Wien",
|
||||
stammVereinId = stammVereinId,
|
||||
mitgliedsNummerIntern = "M12345",
|
||||
letzteZahlungJahr = 2023,
|
||||
feiId = "FEI12345",
|
||||
istGesperrt = false,
|
||||
sperrGrund = null,
|
||||
rollen = rollen,
|
||||
lizenzen = lizenzen,
|
||||
qualifikationenRichter = qualifikationenRichter,
|
||||
qualifikationenParcoursbauer = qualifikationenParcoursbauer,
|
||||
istAktiv = true,
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, person.id)
|
||||
assertEquals("12345", person.oepsSatzNr)
|
||||
assertEquals("Vollständig", person.nachname)
|
||||
assertEquals("Victoria", person.vorname)
|
||||
assertEquals("Dr.", person.titel)
|
||||
assertEquals(geburtsdatum, person.geburtsdatum)
|
||||
assertEquals(Geschlecht.W, person.geschlecht)
|
||||
assertEquals("AUT", person.nationalitaet)
|
||||
assertEquals("victoria@example.com", person.email)
|
||||
assertEquals("+43 123 456789", person.telefon)
|
||||
assertEquals("Musterstraße 1", person.adresse)
|
||||
assertEquals("1010", person.plz)
|
||||
assertEquals("Wien", person.ort)
|
||||
assertEquals(stammVereinId, person.stammVereinId)
|
||||
assertEquals("M12345", person.mitgliedsNummerIntern)
|
||||
assertEquals(2023, person.letzteZahlungJahr)
|
||||
assertEquals("FEI12345", person.feiId)
|
||||
assertEquals(false, person.istGesperrt)
|
||||
assertEquals(null, person.sperrGrund)
|
||||
assertEquals(rollen, person.rollen)
|
||||
assertEquals(lizenzen, person.lizenzen)
|
||||
assertEquals(qualifikationenRichter, person.qualifikationenRichter)
|
||||
assertEquals(qualifikationenParcoursbauer, person.qualifikationenParcoursbauer)
|
||||
assertEquals(true, person.istAktiv)
|
||||
assertEquals(now, person.createdAt)
|
||||
assertEquals(now, person.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyPerson() {
|
||||
// Create a Person
|
||||
val person = Person(
|
||||
oepsSatzNr = null,
|
||||
nachname = "Original",
|
||||
vorname = "Otto",
|
||||
titel = null,
|
||||
geburtsdatum = null,
|
||||
geschlecht = null,
|
||||
nationalitaet = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
stammVereinId = null,
|
||||
mitgliedsNummerIntern = null,
|
||||
letzteZahlungJahr = null,
|
||||
feiId = null,
|
||||
sperrGrund = null
|
||||
)
|
||||
|
||||
val originalUpdatedAt = person.updatedAt
|
||||
val stammVereinId = uuid4()
|
||||
val geburtsdatum = LocalDate(1985, 5, 20)
|
||||
val rollen = setOf(FunktionaerRolle.PARCOURSBAUER)
|
||||
val lizenzen = listOf(
|
||||
LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.FAHRER,
|
||||
stufe = "B",
|
||||
sparte = Sparte.DRESSUR,
|
||||
gueltigBisJahr = 2025,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
)
|
||||
|
||||
// Modify properties
|
||||
person.oepsSatzNr = "54321"
|
||||
person.nachname = "Updated"
|
||||
person.vorname = "Ulrike"
|
||||
person.titel = "Mag."
|
||||
person.geburtsdatum = geburtsdatum
|
||||
person.geschlecht = Geschlecht.W
|
||||
person.nationalitaet = "GER"
|
||||
person.email = "ulrike@example.com"
|
||||
person.telefon = "+49 987 654321"
|
||||
person.adresse = "Neue Straße 2"
|
||||
person.plz = "10115"
|
||||
person.ort = "Berlin"
|
||||
person.stammVereinId = stammVereinId
|
||||
person.mitgliedsNummerIntern = "M54321"
|
||||
person.letzteZahlungJahr = 2024
|
||||
person.feiId = "FEI54321"
|
||||
person.istGesperrt = true
|
||||
person.sperrGrund = "Administrativer Grund"
|
||||
person.rollen = rollen
|
||||
person.lizenzen = lizenzen
|
||||
person.qualifikationenRichter = listOf("Neue Qualifikation")
|
||||
person.qualifikationenParcoursbauer = listOf("Parcours A", "Parcours B")
|
||||
person.istAktiv = false
|
||||
person.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("54321", person.oepsSatzNr)
|
||||
assertEquals("Updated", person.nachname)
|
||||
assertEquals("Ulrike", person.vorname)
|
||||
assertEquals("Mag.", person.titel)
|
||||
assertEquals(geburtsdatum, person.geburtsdatum)
|
||||
assertEquals(Geschlecht.W, person.geschlecht)
|
||||
assertEquals("GER", person.nationalitaet)
|
||||
assertEquals("ulrike@example.com", person.email)
|
||||
assertEquals("+49 987 654321", person.telefon)
|
||||
assertEquals("Neue Straße 2", person.adresse)
|
||||
assertEquals("10115", person.plz)
|
||||
assertEquals("Berlin", person.ort)
|
||||
assertEquals(stammVereinId, person.stammVereinId)
|
||||
assertEquals("M54321", person.mitgliedsNummerIntern)
|
||||
assertEquals(2024, person.letzteZahlungJahr)
|
||||
assertEquals("FEI54321", person.feiId)
|
||||
assertEquals(true, person.istGesperrt)
|
||||
assertEquals("Administrativer Grund", person.sperrGrund)
|
||||
assertEquals(rollen, person.rollen)
|
||||
assertEquals(lizenzen, person.lizenzen)
|
||||
assertEquals(listOf("Neue Qualifikation"), person.qualifikationenRichter)
|
||||
assertEquals(listOf("Parcours A", "Parcours B"), person.qualifikationenParcoursbauer)
|
||||
assertEquals(false, person.istAktiv)
|
||||
assertNotEquals(originalUpdatedAt, person.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a Person with all parameters
|
||||
val stammVereinId = uuid4()
|
||||
val geburtsdatum = LocalDate(1980, 3, 10)
|
||||
val rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.STEWARD)
|
||||
val lizenzen = listOf(
|
||||
LizenzInfo(
|
||||
lizenzTyp = LizenzTyp.REITER,
|
||||
stufe = "A",
|
||||
sparte = Sparte.SPRINGEN,
|
||||
gueltigBisJahr = 2024,
|
||||
ausgestelltAm = null
|
||||
)
|
||||
)
|
||||
|
||||
val person = Person(
|
||||
oepsSatzNr = "12345",
|
||||
nachname = "Serialization",
|
||||
vorname = "Samuel",
|
||||
titel = "Prof.",
|
||||
geburtsdatum = geburtsdatum,
|
||||
geschlecht = Geschlecht.M,
|
||||
nationalitaet = "AUT",
|
||||
email = "samuel@example.com",
|
||||
telefon = "+43 123 456789",
|
||||
adresse = "Testgasse 3",
|
||||
plz = "8010",
|
||||
ort = "Graz",
|
||||
stammVereinId = stammVereinId,
|
||||
mitgliedsNummerIntern = "M12345",
|
||||
letzteZahlungJahr = 2023,
|
||||
feiId = "FEI12345",
|
||||
istGesperrt = false,
|
||||
sperrGrund = null,
|
||||
rollen = rollen,
|
||||
lizenzen = lizenzen,
|
||||
qualifikationenRichter = listOf("Springen A"),
|
||||
qualifikationenParcoursbauer = emptyList(),
|
||||
istAktiv = true
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(person)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"nachname\""), "JSON should contain nachname field")
|
||||
assertTrue(jsonString.contains("\"Serialization\""), "JSON should contain value Serialization")
|
||||
assertTrue(jsonString.contains("\"vorname\""), "JSON should contain vorname field")
|
||||
assertTrue(jsonString.contains("\"Samuel\""), "JSON should contain value Samuel")
|
||||
assertTrue(jsonString.contains("\"geschlecht\""), "JSON should contain geschlecht field")
|
||||
assertTrue(jsonString.contains("\"M\""), "JSON should contain value M")
|
||||
assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field")
|
||||
assertTrue(jsonString.contains("\"stammVereinId\""), "JSON should contain stammVereinId field")
|
||||
assertTrue(jsonString.contains(stammVereinId.toString()), "JSON should contain stammVereinId value")
|
||||
assertTrue(jsonString.contains("\"rollen\""), "JSON should contain rollen field")
|
||||
assertTrue(jsonString.contains("\"RICHTER\""), "JSON should contain value RICHTER")
|
||||
assertTrue(jsonString.contains("\"STEWARD\""), "JSON should contain value STEWARD")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedPerson = json.decodeFromString<Person>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(person.id, deserializedPerson.id)
|
||||
assertEquals(person.oepsSatzNr, deserializedPerson.oepsSatzNr)
|
||||
assertEquals(person.nachname, deserializedPerson.nachname)
|
||||
assertEquals(person.vorname, deserializedPerson.vorname)
|
||||
assertEquals(person.titel, deserializedPerson.titel)
|
||||
assertEquals(person.geburtsdatum, deserializedPerson.geburtsdatum)
|
||||
assertEquals(person.geschlecht, deserializedPerson.geschlecht)
|
||||
assertEquals(person.nationalitaet, deserializedPerson.nationalitaet)
|
||||
assertEquals(person.email, deserializedPerson.email)
|
||||
assertEquals(person.telefon, deserializedPerson.telefon)
|
||||
assertEquals(person.adresse, deserializedPerson.adresse)
|
||||
assertEquals(person.plz, deserializedPerson.plz)
|
||||
assertEquals(person.ort, deserializedPerson.ort)
|
||||
assertEquals(person.stammVereinId, deserializedPerson.stammVereinId)
|
||||
assertEquals(person.mitgliedsNummerIntern, deserializedPerson.mitgliedsNummerIntern)
|
||||
assertEquals(person.letzteZahlungJahr, deserializedPerson.letzteZahlungJahr)
|
||||
assertEquals(person.feiId, deserializedPerson.feiId)
|
||||
assertEquals(person.istGesperrt, deserializedPerson.istGesperrt)
|
||||
assertEquals(person.sperrGrund, deserializedPerson.sperrGrund)
|
||||
assertEquals(person.rollen, deserializedPerson.rollen)
|
||||
assertEquals(person.lizenzen, deserializedPerson.lizenzen)
|
||||
assertEquals(person.qualifikationenRichter, deserializedPerson.qualifikationenRichter)
|
||||
assertEquals(person.qualifikationenParcoursbauer, deserializedPerson.qualifikationenParcoursbauer)
|
||||
assertEquals(person.istAktiv, deserializedPerson.istAktiv)
|
||||
assertEquals(person.createdAt, deserializedPerson.createdAt)
|
||||
assertEquals(person.updatedAt, deserializedPerson.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyPerson() {
|
||||
// Create a Person
|
||||
val original = Person(
|
||||
oepsSatzNr = null,
|
||||
nachname = "Original",
|
||||
vorname = "Otto",
|
||||
titel = null,
|
||||
geburtsdatum = null,
|
||||
geschlecht = null,
|
||||
nationalitaet = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
stammVereinId = null,
|
||||
mitgliedsNummerIntern = null,
|
||||
letzteZahlungJahr = null,
|
||||
feiId = null,
|
||||
sperrGrund = null
|
||||
)
|
||||
|
||||
val stammVereinId = uuid4()
|
||||
val geburtsdatum = LocalDate(1975, 8, 30)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
nachname = "Copy",
|
||||
vorname = "Clara",
|
||||
geburtsdatum = geburtsdatum,
|
||||
stammVereinId = stammVereinId,
|
||||
rollen = setOf(FunktionaerRolle.ZEITNEHMER)
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.oepsSatzNr, copy.oepsSatzNr)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Copy", copy.nachname)
|
||||
assertEquals("Clara", copy.vorname)
|
||||
assertEquals(geburtsdatum, copy.geburtsdatum)
|
||||
assertEquals(stammVereinId, copy.stammVereinId)
|
||||
assertEquals(setOf(FunktionaerRolle.ZEITNEHMER), copy.rollen)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,317 @@
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.shared.model.enums.GeschlechtPferd
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class PferdTest {
|
||||
|
||||
@Test
|
||||
fun testCreatePferd() {
|
||||
// Create a Pferd with minimal required parameters
|
||||
val pferd = Pferd(
|
||||
oepsKopfNr = null,
|
||||
oepsSatzNr = null,
|
||||
name = "Test Pferd",
|
||||
lebensnummer = null,
|
||||
feiPassNr = null,
|
||||
geschlecht = null,
|
||||
geburtsjahr = null,
|
||||
rasse = null,
|
||||
farbe = null,
|
||||
vaterName = null,
|
||||
mutterName = null,
|
||||
mutterVaterName = null,
|
||||
besitzerId = null,
|
||||
verantwortlichePersonId = null,
|
||||
heimatVereinId = null,
|
||||
letzteZahlungJahrOeps = null,
|
||||
stockmassCm = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("Test Pferd", pferd.name)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(pferd.id)
|
||||
assertTrue(pferd.istAktiv)
|
||||
assertNotNull(pferd.createdAt)
|
||||
assertNotNull(pferd.updatedAt)
|
||||
|
||||
// Verify optional fields are null
|
||||
assertEquals(null, pferd.oepsKopfNr)
|
||||
assertEquals(null, pferd.oepsSatzNr)
|
||||
assertEquals(null, pferd.lebensnummer)
|
||||
assertEquals(null, pferd.feiPassNr)
|
||||
assertEquals(null, pferd.geschlecht)
|
||||
assertEquals(null, pferd.geburtsjahr)
|
||||
assertEquals(null, pferd.rasse)
|
||||
assertEquals(null, pferd.farbe)
|
||||
assertEquals(null, pferd.vaterName)
|
||||
assertEquals(null, pferd.mutterName)
|
||||
assertEquals(null, pferd.mutterVaterName)
|
||||
assertEquals(null, pferd.besitzerId)
|
||||
assertEquals(null, pferd.verantwortlichePersonId)
|
||||
assertEquals(null, pferd.heimatVereinId)
|
||||
assertEquals(null, pferd.letzteZahlungJahrOeps)
|
||||
assertEquals(null, pferd.stockmassCm)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreatePferdWithAllParameters() {
|
||||
// Create a Pferd with all parameters
|
||||
val id = uuid4()
|
||||
val besitzerId = uuid4()
|
||||
val verantwortlichePersonId = uuid4()
|
||||
val heimatVereinId = uuid4()
|
||||
val now = Clock.System.now()
|
||||
|
||||
val pferd = Pferd(
|
||||
id = id,
|
||||
oepsKopfNr = "K12345",
|
||||
oepsSatzNr = "S12345",
|
||||
name = "Vollständiges Pferd",
|
||||
lebensnummer = "AT123456789",
|
||||
feiPassNr = "FEI12345",
|
||||
geschlecht = GeschlechtPferd.WALLACH,
|
||||
geburtsjahr = 2015,
|
||||
rasse = "Hannoveraner",
|
||||
farbe = "Fuchs",
|
||||
vaterName = "Vater Pferd",
|
||||
mutterName = "Mutter Pferd",
|
||||
mutterVaterName = "Muttervater Pferd",
|
||||
besitzerId = besitzerId,
|
||||
verantwortlichePersonId = verantwortlichePersonId,
|
||||
heimatVereinId = heimatVereinId,
|
||||
letzteZahlungJahrOeps = 2023,
|
||||
stockmassCm = 168,
|
||||
istAktiv = true,
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, pferd.id)
|
||||
assertEquals("K12345", pferd.oepsKopfNr)
|
||||
assertEquals("S12345", pferd.oepsSatzNr)
|
||||
assertEquals("Vollständiges Pferd", pferd.name)
|
||||
assertEquals("AT123456789", pferd.lebensnummer)
|
||||
assertEquals("FEI12345", pferd.feiPassNr)
|
||||
assertEquals(GeschlechtPferd.WALLACH, pferd.geschlecht)
|
||||
assertEquals(2015, pferd.geburtsjahr)
|
||||
assertEquals("Hannoveraner", pferd.rasse)
|
||||
assertEquals("Fuchs", pferd.farbe)
|
||||
assertEquals("Vater Pferd", pferd.vaterName)
|
||||
assertEquals("Mutter Pferd", pferd.mutterName)
|
||||
assertEquals("Muttervater Pferd", pferd.mutterVaterName)
|
||||
assertEquals(besitzerId, pferd.besitzerId)
|
||||
assertEquals(verantwortlichePersonId, pferd.verantwortlichePersonId)
|
||||
assertEquals(heimatVereinId, pferd.heimatVereinId)
|
||||
assertEquals(2023, pferd.letzteZahlungJahrOeps)
|
||||
assertEquals(168, pferd.stockmassCm)
|
||||
assertEquals(true, pferd.istAktiv)
|
||||
assertEquals(now, pferd.createdAt)
|
||||
assertEquals(now, pferd.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyPferd() {
|
||||
// Create a Pferd
|
||||
val pferd = Pferd(
|
||||
oepsKopfNr = null,
|
||||
oepsSatzNr = null,
|
||||
name = "Test Pferd",
|
||||
lebensnummer = null,
|
||||
feiPassNr = null,
|
||||
geschlecht = null,
|
||||
geburtsjahr = null,
|
||||
rasse = null,
|
||||
farbe = null,
|
||||
vaterName = null,
|
||||
mutterName = null,
|
||||
mutterVaterName = null,
|
||||
besitzerId = null,
|
||||
verantwortlichePersonId = null,
|
||||
heimatVereinId = null,
|
||||
letzteZahlungJahrOeps = null,
|
||||
stockmassCm = null
|
||||
)
|
||||
|
||||
val originalUpdatedAt = pferd.updatedAt
|
||||
val besitzerId = uuid4()
|
||||
val verantwortlichePersonId = uuid4()
|
||||
val heimatVereinId = uuid4()
|
||||
|
||||
// Modify properties
|
||||
pferd.oepsKopfNr = "K54321"
|
||||
pferd.oepsSatzNr = "S54321"
|
||||
pferd.name = "Updated Pferd"
|
||||
pferd.lebensnummer = "AT987654321"
|
||||
pferd.feiPassNr = "FEI54321"
|
||||
pferd.geschlecht = GeschlechtPferd.STUTE
|
||||
pferd.geburtsjahr = 2018
|
||||
pferd.rasse = "Trakehner"
|
||||
pferd.farbe = "Rappe"
|
||||
pferd.vaterName = "Neuer Vater"
|
||||
pferd.mutterName = "Neue Mutter"
|
||||
pferd.mutterVaterName = "Neuer Muttervater"
|
||||
pferd.besitzerId = besitzerId
|
||||
pferd.verantwortlichePersonId = verantwortlichePersonId
|
||||
pferd.heimatVereinId = heimatVereinId
|
||||
pferd.letzteZahlungJahrOeps = 2024
|
||||
pferd.stockmassCm = 165
|
||||
pferd.istAktiv = false
|
||||
pferd.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("K54321", pferd.oepsKopfNr)
|
||||
assertEquals("S54321", pferd.oepsSatzNr)
|
||||
assertEquals("Updated Pferd", pferd.name)
|
||||
assertEquals("AT987654321", pferd.lebensnummer)
|
||||
assertEquals("FEI54321", pferd.feiPassNr)
|
||||
assertEquals(GeschlechtPferd.STUTE, pferd.geschlecht)
|
||||
assertEquals(2018, pferd.geburtsjahr)
|
||||
assertEquals("Trakehner", pferd.rasse)
|
||||
assertEquals("Rappe", pferd.farbe)
|
||||
assertEquals("Neuer Vater", pferd.vaterName)
|
||||
assertEquals("Neue Mutter", pferd.mutterName)
|
||||
assertEquals("Neuer Muttervater", pferd.mutterVaterName)
|
||||
assertEquals(besitzerId, pferd.besitzerId)
|
||||
assertEquals(verantwortlichePersonId, pferd.verantwortlichePersonId)
|
||||
assertEquals(heimatVereinId, pferd.heimatVereinId)
|
||||
assertEquals(2024, pferd.letzteZahlungJahrOeps)
|
||||
assertEquals(165, pferd.stockmassCm)
|
||||
assertEquals(false, pferd.istAktiv)
|
||||
assertNotEquals(originalUpdatedAt, pferd.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a Pferd with all parameters
|
||||
val besitzerId = uuid4()
|
||||
val verantwortlichePersonId = uuid4()
|
||||
val heimatVereinId = uuid4()
|
||||
|
||||
val pferd = Pferd(
|
||||
oepsKopfNr = "K12345",
|
||||
oepsSatzNr = "S12345",
|
||||
name = "Serialization Pferd",
|
||||
lebensnummer = "AT123456789",
|
||||
feiPassNr = "FEI12345",
|
||||
geschlecht = GeschlechtPferd.HENGST,
|
||||
geburtsjahr = 2016,
|
||||
rasse = "Holsteiner",
|
||||
farbe = "Schimmel",
|
||||
vaterName = "Vater Pferd",
|
||||
mutterName = "Mutter Pferd",
|
||||
mutterVaterName = "Muttervater Pferd",
|
||||
besitzerId = besitzerId,
|
||||
verantwortlichePersonId = verantwortlichePersonId,
|
||||
heimatVereinId = heimatVereinId,
|
||||
letzteZahlungJahrOeps = 2023,
|
||||
stockmassCm = 170,
|
||||
istAktiv = true
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(pferd)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"name\""), "JSON should contain name field")
|
||||
assertTrue(jsonString.contains("\"Serialization Pferd\""), "JSON should contain value Serialization Pferd")
|
||||
assertTrue(jsonString.contains("\"geschlecht\""), "JSON should contain geschlecht field")
|
||||
assertTrue(jsonString.contains("\"HENGST\""), "JSON should contain value HENGST")
|
||||
assertTrue(jsonString.contains("\"rasse\""), "JSON should contain rasse field")
|
||||
assertTrue(jsonString.contains("\"Holsteiner\""), "JSON should contain value Holsteiner")
|
||||
assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field")
|
||||
assertTrue(jsonString.contains("\"besitzerId\""), "JSON should contain besitzerId field")
|
||||
assertTrue(jsonString.contains(besitzerId.toString()), "JSON should contain besitzerId value")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedPferd = json.decodeFromString<Pferd>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(pferd.id, deserializedPferd.id)
|
||||
assertEquals(pferd.oepsKopfNr, deserializedPferd.oepsKopfNr)
|
||||
assertEquals(pferd.oepsSatzNr, deserializedPferd.oepsSatzNr)
|
||||
assertEquals(pferd.name, deserializedPferd.name)
|
||||
assertEquals(pferd.lebensnummer, deserializedPferd.lebensnummer)
|
||||
assertEquals(pferd.feiPassNr, deserializedPferd.feiPassNr)
|
||||
assertEquals(pferd.geschlecht, deserializedPferd.geschlecht)
|
||||
assertEquals(pferd.geburtsjahr, deserializedPferd.geburtsjahr)
|
||||
assertEquals(pferd.rasse, deserializedPferd.rasse)
|
||||
assertEquals(pferd.farbe, deserializedPferd.farbe)
|
||||
assertEquals(pferd.vaterName, deserializedPferd.vaterName)
|
||||
assertEquals(pferd.mutterName, deserializedPferd.mutterName)
|
||||
assertEquals(pferd.mutterVaterName, deserializedPferd.mutterVaterName)
|
||||
assertEquals(pferd.besitzerId, deserializedPferd.besitzerId)
|
||||
assertEquals(pferd.verantwortlichePersonId, deserializedPferd.verantwortlichePersonId)
|
||||
assertEquals(pferd.heimatVereinId, deserializedPferd.heimatVereinId)
|
||||
assertEquals(pferd.letzteZahlungJahrOeps, deserializedPferd.letzteZahlungJahrOeps)
|
||||
assertEquals(pferd.stockmassCm, deserializedPferd.stockmassCm)
|
||||
assertEquals(pferd.istAktiv, deserializedPferd.istAktiv)
|
||||
assertEquals(pferd.createdAt, deserializedPferd.createdAt)
|
||||
assertEquals(pferd.updatedAt, deserializedPferd.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyPferd() {
|
||||
// Create a Pferd
|
||||
val original = Pferd(
|
||||
oepsKopfNr = null,
|
||||
oepsSatzNr = null,
|
||||
name = "Original Pferd",
|
||||
lebensnummer = null,
|
||||
feiPassNr = null,
|
||||
geschlecht = null,
|
||||
geburtsjahr = null,
|
||||
rasse = null,
|
||||
farbe = null,
|
||||
vaterName = null,
|
||||
mutterName = null,
|
||||
mutterVaterName = null,
|
||||
besitzerId = null,
|
||||
verantwortlichePersonId = null,
|
||||
heimatVereinId = null,
|
||||
letzteZahlungJahrOeps = null,
|
||||
stockmassCm = null
|
||||
)
|
||||
|
||||
val besitzerId = uuid4()
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
name = "Copy Pferd",
|
||||
rasse = "Arabisches Vollblut",
|
||||
besitzerId = besitzerId
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.oepsKopfNr, copy.oepsKopfNr)
|
||||
assertEquals(original.oepsSatzNr, copy.oepsSatzNr)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Copy Pferd", copy.name)
|
||||
assertEquals("Arabisches Vollblut", copy.rasse)
|
||||
assertEquals(besitzerId, copy.besitzerId)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
package at.mocode.shared.model.stammdaten
|
||||
|
||||
import at.mocode.shared.model.serializers.KotlinInstantSerializer
|
||||
import at.mocode.shared.model.serializers.UuidSerializer
|
||||
import com.benasher44.uuid.Uuid
|
||||
import com.benasher44.uuid.uuid4
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
import kotlinx.serialization.decodeFromString
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNotEquals
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class VereinTest {
|
||||
|
||||
@Test
|
||||
fun testCreateVerein() {
|
||||
// Create a Verein with minimal required parameters
|
||||
val verein = Verein(
|
||||
oepsVereinsNr = "12345",
|
||||
name = "Test Verein",
|
||||
kuerzel = null,
|
||||
bundesland = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
webseite = null
|
||||
)
|
||||
|
||||
// Verify required fields
|
||||
assertEquals("12345", verein.oepsVereinsNr)
|
||||
assertEquals("Test Verein", verein.name)
|
||||
|
||||
// Verify default values
|
||||
assertNotNull(verein.id)
|
||||
assertTrue(verein.istAktiv)
|
||||
assertNotNull(verein.createdAt)
|
||||
assertNotNull(verein.updatedAt)
|
||||
|
||||
// Verify optional fields are null
|
||||
assertEquals(null, verein.kuerzel)
|
||||
assertEquals(null, verein.bundesland)
|
||||
assertEquals(null, verein.adresse)
|
||||
assertEquals(null, verein.plz)
|
||||
assertEquals(null, verein.ort)
|
||||
assertEquals(null, verein.email)
|
||||
assertEquals(null, verein.telefon)
|
||||
assertEquals(null, verein.webseite)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCreateVereinWithAllParameters() {
|
||||
// Create a Verein with all parameters
|
||||
val id = uuid4()
|
||||
val now = Clock.System.now()
|
||||
|
||||
val verein = Verein(
|
||||
id = id,
|
||||
oepsVereinsNr = "12345",
|
||||
name = "Test Verein",
|
||||
kuerzel = "TV",
|
||||
bundesland = "Wien",
|
||||
adresse = "Teststraße 1",
|
||||
plz = "1010",
|
||||
ort = "Wien",
|
||||
email = "test@verein.at",
|
||||
telefon = "+43 1 234567",
|
||||
webseite = "https://testverein.at",
|
||||
istAktiv = true,
|
||||
createdAt = now,
|
||||
updatedAt = now
|
||||
)
|
||||
|
||||
// Verify all fields
|
||||
assertEquals(id, verein.id)
|
||||
assertEquals("12345", verein.oepsVereinsNr)
|
||||
assertEquals("Test Verein", verein.name)
|
||||
assertEquals("TV", verein.kuerzel)
|
||||
assertEquals("Wien", verein.bundesland)
|
||||
assertEquals("Teststraße 1", verein.adresse)
|
||||
assertEquals("1010", verein.plz)
|
||||
assertEquals("Wien", verein.ort)
|
||||
assertEquals("test@verein.at", verein.email)
|
||||
assertEquals("+43 1 234567", verein.telefon)
|
||||
assertEquals("https://testverein.at", verein.webseite)
|
||||
assertEquals(true, verein.istAktiv)
|
||||
assertEquals(now, verein.createdAt)
|
||||
assertEquals(now, verein.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testModifyVerein() {
|
||||
// Create a Verein
|
||||
val verein = Verein(
|
||||
oepsVereinsNr = "12345",
|
||||
name = "Test Verein",
|
||||
kuerzel = null,
|
||||
bundesland = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
webseite = null
|
||||
)
|
||||
|
||||
val originalUpdatedAt = verein.updatedAt
|
||||
|
||||
// Modify properties
|
||||
verein.oepsVereinsNr = "54321"
|
||||
verein.name = "Updated Verein"
|
||||
verein.kuerzel = "UV"
|
||||
verein.bundesland = "Salzburg"
|
||||
verein.adresse = "Neue Straße 2"
|
||||
verein.plz = "5020"
|
||||
verein.ort = "Salzburg"
|
||||
verein.email = "updated@verein.at"
|
||||
verein.telefon = "+43 662 123456"
|
||||
verein.webseite = "https://updatedverein.at"
|
||||
verein.istAktiv = false
|
||||
verein.updatedAt = Clock.System.now()
|
||||
|
||||
// Verify modifications
|
||||
assertEquals("54321", verein.oepsVereinsNr)
|
||||
assertEquals("Updated Verein", verein.name)
|
||||
assertEquals("UV", verein.kuerzel)
|
||||
assertEquals("Salzburg", verein.bundesland)
|
||||
assertEquals("Neue Straße 2", verein.adresse)
|
||||
assertEquals("5020", verein.plz)
|
||||
assertEquals("Salzburg", verein.ort)
|
||||
assertEquals("updated@verein.at", verein.email)
|
||||
assertEquals("+43 662 123456", verein.telefon)
|
||||
assertEquals("https://updatedverein.at", verein.webseite)
|
||||
assertEquals(false, verein.istAktiv)
|
||||
assertNotEquals(originalUpdatedAt, verein.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSerializationDeserialization() {
|
||||
// Create a Verein with all parameters
|
||||
val verein = Verein(
|
||||
oepsVereinsNr = "12345",
|
||||
name = "Test Verein",
|
||||
kuerzel = "TV",
|
||||
bundesland = "Wien",
|
||||
adresse = "Teststraße 1",
|
||||
plz = "1010",
|
||||
ort = "Wien",
|
||||
email = "test@verein.at",
|
||||
telefon = "+43 1 234567",
|
||||
webseite = "https://testverein.at",
|
||||
istAktiv = true
|
||||
)
|
||||
|
||||
// Serialize to JSON
|
||||
val json = Json {
|
||||
prettyPrint = true
|
||||
encodeDefaults = true
|
||||
}
|
||||
val jsonString = json.encodeToString(verein)
|
||||
|
||||
// Verify JSON contains expected fields
|
||||
assertTrue(jsonString.contains("\"oepsVereinsNr\""), "JSON should contain oepsVereinsNr field")
|
||||
assertTrue(jsonString.contains("\"12345\""), "JSON should contain value 12345")
|
||||
assertTrue(jsonString.contains("\"name\""), "JSON should contain name field")
|
||||
assertTrue(jsonString.contains("\"Test Verein\""), "JSON should contain value Test Verein")
|
||||
assertTrue(jsonString.contains("\"kuerzel\""), "JSON should contain kuerzel field")
|
||||
assertTrue(jsonString.contains("\"TV\""), "JSON should contain value TV")
|
||||
assertTrue(jsonString.contains("\"bundesland\""), "JSON should contain bundesland field")
|
||||
assertTrue(jsonString.contains("\"Wien\""), "JSON should contain value Wien")
|
||||
assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field")
|
||||
|
||||
// Deserialize from JSON
|
||||
val deserializedVerein = json.decodeFromString<Verein>(jsonString)
|
||||
|
||||
// Verify deserialized object matches original
|
||||
assertEquals(verein.id, deserializedVerein.id)
|
||||
assertEquals(verein.oepsVereinsNr, deserializedVerein.oepsVereinsNr)
|
||||
assertEquals(verein.name, deserializedVerein.name)
|
||||
assertEquals(verein.kuerzel, deserializedVerein.kuerzel)
|
||||
assertEquals(verein.bundesland, deserializedVerein.bundesland)
|
||||
assertEquals(verein.adresse, deserializedVerein.adresse)
|
||||
assertEquals(verein.plz, deserializedVerein.plz)
|
||||
assertEquals(verein.ort, deserializedVerein.ort)
|
||||
assertEquals(verein.email, deserializedVerein.email)
|
||||
assertEquals(verein.telefon, deserializedVerein.telefon)
|
||||
assertEquals(verein.webseite, deserializedVerein.webseite)
|
||||
assertEquals(verein.istAktiv, deserializedVerein.istAktiv)
|
||||
assertEquals(verein.createdAt, deserializedVerein.createdAt)
|
||||
assertEquals(verein.updatedAt, deserializedVerein.updatedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testCopyVerein() {
|
||||
// Create a Verein
|
||||
val original = Verein(
|
||||
oepsVereinsNr = "12345",
|
||||
name = "Test Verein",
|
||||
kuerzel = null,
|
||||
bundesland = null,
|
||||
adresse = null,
|
||||
plz = null,
|
||||
ort = null,
|
||||
email = null,
|
||||
telefon = null,
|
||||
webseite = null
|
||||
)
|
||||
|
||||
// Create a copy with some modified properties
|
||||
val copy = original.copy(
|
||||
name = "Copy Verein",
|
||||
bundesland = "Tirol"
|
||||
)
|
||||
|
||||
// Verify copied properties
|
||||
assertEquals(original.id, copy.id)
|
||||
assertEquals(original.oepsVereinsNr, copy.oepsVereinsNr)
|
||||
assertEquals(original.createdAt, copy.createdAt)
|
||||
assertEquals(original.updatedAt, copy.updatedAt)
|
||||
|
||||
// Verify modified properties
|
||||
assertEquals("Copy Verein", copy.name)
|
||||
assertEquals("Tirol", copy.bundesland)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user