1 files changed, 171 insertions, 0 deletions
diff --git a/runtime/jsTest/src/kotlinx/serialization/DynamicParserTest.kt b/runtime/jsTest/src/kotlinx/serialization/DynamicParserTest.kt
new file mode 100644
index 00000000..593b8c0f
--- /dev/null
+++ b/runtime/jsTest/src/kotlinx/serialization/DynamicParserTest.kt
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2018 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kotlinx.serialization
+
+import kotlinx.serialization.modules.serializersModuleOf
+import kotlinx.serialization.internal.SerialClassDescImpl
+import kotlin.test.*
+
+class DynamicParserTest {
+    @Serializable
+    data class Data(val a: Int)
+
+    @Serializable
+    data class DataWrapper(val s: String, val d: Data?)
+
+    @Serializable
+    data class DataWrapperOptional(val s: String,val d: Data? = null)
+
+    @Serializable
+    data class IntList(val l: List<Int>)
+
+    @Serializable
+    data class ListOfLists(val l: List<List<Data>>)
+
+    @Serializable
+    data class MapWrapper(val m: Map<String, Int>)
+
+    @Serializable
+    data class ComplexMapWrapper(val m: Map<String, Data>)
+
+    @Serializable
+    data class WithChar(val a: Char)
+
+    @Serializable
+    data class AllTypes(
+            val b: Byte,
+            val s: Short,
+            val i: Int,
+            val f: Float,
+            val d: Double,
+            val c: Char,
+            val B: Boolean,
+            val S: String
+    )
+
+    @Serializable
+    data class NonTrivialMap(val m: Map<String, Char>)
+
+    data class NotDefault(val a: Int)
+
+    object NDSerializer : KSerializer<NotDefault> {
+        override fun serialize(encoder: Encoder, obj: NotDefault) {
+            encoder.encodeInt(obj.a)
+        }
+
+        override fun deserialize(decoder: Decoder): NotDefault {
+            return NotDefault(decoder.decodeInt())
+        }
+
+        override val descriptor = SerialClassDescImpl("notDefault")
+    }
+
+    @Serializable
+    data class NDWrapper(@ContextualSerialization val data: NotDefault)
+
+    @Test
+    fun dynamicSimpleTest() {
+        val dyn = js("{a: 42}")
+        val parsed = DynamicObjectParser().parse(dyn, Data.serializer())
+        assertEquals(Data(42), parsed)
+
+        val dyn2 = js("{a: 'a'}")
+        val parsed2 = DynamicObjectParser().parse(dyn2, WithChar.serializer())
+        assertEquals(WithChar('a'), parsed2)
+
+        val dyn3 = js("{a: 97}")
+        val parsed3 = DynamicObjectParser().parse(dyn3, WithChar.serializer())
+        assertEquals(WithChar('a'), parsed3)
+    }
+
+    @Test
+    fun dynamicAllTypesTest() {
+        val dyn = js("""{ b: 1, s: 2, i: 3, f: 1.0, d: 42.0, c: 'a', B: true, S: "str"}""")
+        val kotlinObj = AllTypes(1, 2, 3, 1.0f, 42.0, 'a', true, "str")
+
+        assertEquals(kotlinObj, DynamicObjectParser().parse(dyn))
+    }
+
+    @Test
+    fun dynamicNestedTest() {
+        val dyn = js("""{s:"foo", d:{a:42}}""")
+        val parsed = DynamicObjectParser().parse<DataWrapper>(dyn)
+        val expected = DataWrapper("foo", Data(42))
+        assertEquals(expected, parsed)
+        assertEquals(3, parsed.s.length)
+        assertFailsWith(ClassCastException::class) { dyn as DataWrapper }
+    }
+
+    @Test
+    fun dynamicNullableTest() {
+        val dyn1 = js("""({s:"foo", d: null})""")
+        val dyn2 = js("""({s:"foo"})""")
+        val dyn3 = js("""({s:"foo", d: undefined})""")
+
+        assertEquals(DataWrapper("foo", null), DynamicObjectParser().parse<DataWrapper>(dyn1))
+        assertFailsWith(MissingFieldException::class) { DynamicObjectParser().parse<DataWrapper>(dyn2) }
+        assertFailsWith(MissingFieldException::class) { DynamicObjectParser().parse<DataWrapper>(dyn3) }
+    }
+
+    @Test
+    fun dynamicOptionalTest() {
+        val dyn1 = js("""({s:"foo", d: null})""")
+        val dyn2 = js("""({s:"foo"})""")
+        val dyn3 = js("""({s:"foo", d: undefined})""")
+
+        assertEquals(DataWrapperOptional("foo", null), DynamicObjectParser().parse<DataWrapperOptional>(dyn1))
+        assertEquals(DataWrapperOptional("foo", null), DynamicObjectParser().parse<DataWrapperOptional>(dyn2))
+        assertEquals(DataWrapperOptional("foo", null), DynamicObjectParser().parse<DataWrapperOptional>(dyn3))
+    }
+
+    @Test
+    fun dynamicListTest() {
+        val dyn1 = js("""({l:[1,2]})""")
+        val dyn2 = js("""({l:[[],[{a:42}]]})""")
+
+        assertEquals(IntList(listOf(1, 2)), DynamicObjectParser().parse<IntList>(dyn1))
+        assertEquals(ListOfLists(listOf(listOf(), listOf(Data(42)))), DynamicObjectParser().parse<ListOfLists>(dyn2))
+    }
+
+    @Test
+    fun dynamicMapTest() {
+        val dyn = js("({m : {\"a\": 1, \"b\" : 2}})")
+        val m = MapWrapper(mapOf("a" to 1, "b" to 2))
+        assertEquals(m, DynamicObjectParser().parse<MapWrapper>(dyn))
+    }
+
+    @Test
+    fun testFunnyMap() {
+        val dyn = js("({m : {\"a\": 'b', \"b\" : 'a'}})")
+        val m = NonTrivialMap(mapOf("a" to 'b', "b" to 'a'))
+        assertEquals(m, DynamicObjectParser().parse(dyn))
+    }
+
+    @Test
+    fun dynamicMapComplexTest() {
+        val dyn = js("({m : {1: {a: 42}, 2: {a: 43}}})")
+        val m = ComplexMapWrapper(mapOf("1" to Data(42), "2" to Data(43)))
+        assertEquals(m, DynamicObjectParser().parse<ComplexMapWrapper>(dyn))
+    }
+
+    @Test
+    fun parseWithCustomSerializers() {
+        val deserializer = DynamicObjectParser(context = serializersModuleOf(NotDefault::class, NDSerializer))
+        val dyn1 = js("({data: 42})")
+        assertEquals(NDWrapper(NotDefault(42)), deserializer.parse(dyn1))
+    }
+}