org.jetbrains.kotlinx.jupyter.test.LibraryDescriptorProcessingTest.kt Maven / Gradle / Ivy

Go to download
package org.jetbrains.kotlinx.jupyter.test

import io.kotest.matchers.booleans.shouldBeFalse
import io.kotest.matchers.booleans.shouldBeTrue
import io.kotest.matchers.shouldBe
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import org.jetbrains.kotlinx.jupyter.api.libraries.CodeExecutionCallback
import org.jetbrains.kotlinx.jupyter.api.libraries.LibraryDefinition
import org.jetbrains.kotlinx.jupyter.libraries.LibraryDescriptor
import org.jetbrains.kotlinx.jupyter.libraries.parseLibraryDescriptor
import org.jetbrains.kotlinx.jupyter.libraries.parseLibraryName
import org.junit.jupiter.api.Test

class LibraryDescriptorProcessingTest {
    @Test
    fun `ordered descriptor properties`() =
        doTest(
            "lib(42, abc, y=8)",
            """
            {
                "properties": [
                    {"name": "a", "value": "def1"},
                    {"name": "b", "value": "def2"},
                    {"name": "x", "value": "def3"},
                    {"name": "y", "value": "def4"}
                ],
                "init": [
                    "val a = ${'$'}a",
                    "val b = ${'$'}b",
                    "val x = ${'$'}x",
                    "val y = ${'$'}y"
                ]
            }
            """.trimIndent(),
        ) { definition ->
            definition.init.map { (it as CodeExecutionCallback).code } shouldBe
                listOf(
                    "val a = 42",
                    "val b = abc",
                    "val x = def3",
                    "val y = 8",
                )
        }

    @Test
    fun `ordered descriptors should remain ordered after serialization`() =
        doSerializeDeserializeTest(
            """
            {
                "properties": [
                    {"name": "a", "value": "def1"},
                    {"name": "b", "value": "def2"}
                ]
            }
            """.trimIndent(),
        ) { descriptor ->
            descriptor.variables.hasOrder.shouldBeTrue()
        }

    @Test
    fun `unordered descriptors should remain unordered after serialization`() =
        doSerializeDeserializeTest(
            """
            {
                "properties": {
                    "a": "def1",
                    "b": "def2"
                }
            }
            """.trimIndent(),
        ) { descriptor ->
            descriptor.variables.hasOrder.shouldBeFalse()
        }

    private fun doTest(
        libraryCall: String,
        descriptorString: String,
        definitionChecker: (LibraryDefinition) -> Unit,
    ) {
        val (_, arguments) = parseLibraryName(libraryCall)
        val descriptor = parseLibraryDescriptor(descriptorString)
        val definition = descriptor.convertToDefinition(arguments)
        definitionChecker(definition)
    }

    private fun doSerializeDeserializeTest(
        descriptorString: String,
        descriptorChecker: (LibraryDescriptor) -> Unit,
    ) {
        val descriptor1 = parseLibraryDescriptor(descriptorString)
        val text = Json.encodeToString(descriptor1)
        val descriptor = parseLibraryDescriptor(text)
        descriptorChecker(descriptor)
    }
}