76 lines
2.9 KiB
Kotlin
76 lines
2.9 KiB
Kotlin
package dev.inmo.postssystem.core.api
|
|
|
|
import dev.inmo.micro_utils.common.ByteArrayAllocator
|
|
import dev.inmo.micro_utils.mime_types.KnownMimeTypes
|
|
import dev.inmo.postssystem.core.content.*
|
|
import dev.inmo.postssystem.core.content.api.business.content_adapters.binary.BinaryContent
|
|
import dev.inmo.postssystem.core.content.api.business.content_adapters.text.TextContent
|
|
import dev.inmo.postssystem.core.generateContentId
|
|
import kotlinx.serialization.json.Json
|
|
import kotlinx.serialization.modules.SerializersModule
|
|
import kotlinx.serialization.modules.polymorphic
|
|
import kotlin.test.Test
|
|
import kotlin.test.assertEquals
|
|
|
|
private val jsonFormat = Json {
|
|
serializersModule = SerializersModule {
|
|
polymorphic(Content::class) {
|
|
subclass(TextContent::class, TextContent.serializer())
|
|
subclass(BinaryContent::class, BinaryContent.serializer())
|
|
}
|
|
}
|
|
}
|
|
|
|
class ContentSerialization {
|
|
private val simpleTextTestEntries = 10
|
|
private val simpleSpecialTestEntries = 10
|
|
|
|
@Test
|
|
fun test_that_content_correctly_serializing_and_deserializing() {
|
|
val contents = (0 until simpleTextTestEntries).map {
|
|
TextContent("Example$it")
|
|
} + (0 until simpleSpecialTestEntries).map {
|
|
BinaryContent(KnownMimeTypes.Any, "$it.example") {
|
|
byteArrayOf(it.toByte())
|
|
}
|
|
}
|
|
|
|
val registeredContentFakes = contents.map { content ->
|
|
RegisteredContent(
|
|
generateContentId(),
|
|
content
|
|
)
|
|
}
|
|
|
|
val stringified = registeredContentFakes.map {
|
|
jsonFormat.encodeToString(RegisteredContent.serializer(), it)
|
|
}
|
|
|
|
val parsed = stringified.map {
|
|
jsonFormat.decodeFromString(RegisteredContent.serializer(), it)
|
|
}
|
|
|
|
parsed.forEachIndexed { i, registeredContent ->
|
|
val content = registeredContent.content
|
|
assertEquals(registeredContentFakes[i].id, registeredContent.id)
|
|
when (content) {
|
|
is TextContent -> assertEquals(registeredContentFakes[i].content, content)
|
|
is BinaryContent -> {
|
|
val expectedContent = registeredContentFakes[i].content as BinaryContent
|
|
val fakeByteArrayAllocator: ByteArrayAllocator = { byteArrayOf() }
|
|
assertEquals(
|
|
expectedContent.copy(dataAllocator = fakeByteArrayAllocator),
|
|
content.copy(dataAllocator = fakeByteArrayAllocator)
|
|
)
|
|
val expectedData = expectedContent.dataAllocator()
|
|
val parsedData = content.dataAllocator()
|
|
assertEquals(expectedData.size, parsedData.size)
|
|
expectedData.withIndex().forEach { (i, byte) ->
|
|
assertEquals(byte, parsedData[i])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|