Or .. what do you mean by

share code between my local unit tests

? I interpreted that as sharing code between tests in

src/test/kotlin

and

src/test/java

🤔

class LegacyDeserializationTest : WordSpec({

    val parameterPacketHexString = """
       00 00 00 00 00 00 00 00 00 00 32 31 33....
    """.trimIndent().replace(" ","").replace("\n", "")

    val csvReaderCtx: CsvReaderContext.() -> Unit = {
        charset = Charsets.ISO_8859_1
    }

    fun readTestFile(
        fileName: String,
        ctx: CsvReaderContext.() -> Unit
    ): Sequence<Map<String, String>> {
        val file = File("src/test/resources/$fileName")
        return csvReader(ctx).parseLinesAsSequence(file.inputStream())
    }

    "legacy parser" should {
        "not throw Exception on deserialization" {
            val contents = readTestFile("/webkey-details.csv", csvReaderCtx).asSequence()
            val details = csvMapper<LegacyDetailModel> {
                ignoreUnknownFields = true
                // Actual field name of input to class field name
                customKeyMap = mutableMapOf(
                    "controlType" to "composableType",
                    "default" to "defaultValue",
                    "dataType2" to "dataType",
                    "sinceVersion2" to "sinceVersion",
                    "untilVersion2" to "untilVersion",
                    "deprecated2" to "deprecated"
                )
            }.deserialize(contents)
 
            ...
        }

Basically all of this code is needed for serialization too

The whole csvReader functionality is already tested in

CsvParserTest

file. Did I understand you right that I should drop this file and do the testing of the parser in the deserialization test? I have another question that comes in my mind: When doing the deserialization I produce values which I need for serialization. So the serialization test would base on the deserialization test. Is this legit? And if not how can I work around this? The problem here is that I need all values from deserialization to test serialization properly, so I can't just create a map with 2 or 3 values. Another problem is that the deserialize function is wrapped into

shouldThrow

so I can't write

shouldNotThrow<Exception> {
                webkeys = LegacyParser.deserialize(
                    source = bytes,
                    packetDetails = packetDetails
                )
            }

But I could do

shouldNotThrow<Exception> {
                LegacyParser.deserialize(
                    source = bytes,
                    packetDetails = packetDetails
                ).also { webKeys = it }
            }

Anyway there is no guarantee that the variable is set. Should tests base on other tests? I guess no. But what options do I have otherwise?

When doing the deserialization I produce values which I need for serialization. So the serialization test would base on the deserialization test. Is this legit?

That’s what I usually end up doing when testing serialization, but I just do

original shouldBe deserialize(serialize(original))

. Right now your tests only check that the serialization/deserialization functionality doesn’t throw, which doesn’t say much about whether the serialization is valid. But checking if

x == deserialize(serialize(x))

may be enough, unless you expect some specific format that goes to an external service for example

That would make a lot of problems obsolete

What i can say for sure is that in this specific case the result of deserialization isn't equal to the result of serialization