Test Coverage Added

hosseinkarami-dev · hosseinkarami-dev · commit 95f3b514855d · 2025-10-10T22:56:18.000+03:30
diff --git a/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/ChangesTest.kt b/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/ChangesTest.kt
@@ -45,7 +45,7 @@ class ChangesTest {
 
     @Test
     fun testStatus() = runTest {
-        var response = nearClient.changes(
+        val response = nearClient.changes(
             RpcStateChangesInBlockByTypeRequest.AccountChangesByBlockId(
                 blockId = BlockId.BlockHeight(167697415U),
                 accountIds = listOf(AccountId("relay.tg")),
@@ -55,20 +55,6 @@ class ChangesTest {
         val result = response.getResultOrNull<RpcStateChangesInBlockResponse>()
         println("Changes Response: $result")
 
-        if (response !is RpcResponse.Success)
-            assertTrue { false }
-
-
-        response = nearClient.changes(
-            RpcStateChangesInBlockByTypeRequest.AccountChangesByFinality(
-                accountIds = listOf(AccountId("relay.tg")),
-                changesType = RpcStateChangesInBlockByTypeRequest.AccountChangesByFinality.ChangesType.ACCOUNT_CHANGES,
-                finality = Finality.FINAL
-            )
-        )
-
-        println("Changes Response: $result")
-
         if (response !is RpcResponse.Success)
             assertTrue { false }
 
diff --git a/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/ExperimentalChangesInBlockTest.kt b/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/ExperimentalChangesInBlockTest.kt
@@ -42,8 +42,9 @@ class ExperimentalChangesInBlockTest {
     fun testStatus() = runTest {
         val response = nearClient.experimentalChangesInBlock(RpcStateChangesInBlockRequest.Finality(
             Finality.FINAL))
+
         val result = response.getResultOrNull<RpcStateChangesInBlockByTypeResponse>()
-        println("Experimental Changes In Block Response: $result")
+        println("Experimental Changes In Block Response: $response")
         assertTrue { response is RpcResponse.Success }
     }
 }
diff --git a/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/QueryTest.kt b/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/QueryTest.kt
@@ -0,0 +1,56 @@
+package io.github.hosseinkarami_dev.near.rpc.client
+
+import io.github.hosseinkarami_dev.near.rpc.client.Utils.getResultOrNull
+import io.github.hosseinkarami_dev.near.rpc.models.AccountId
+import io.github.hosseinkarami_dev.near.rpc.models.Finality
+import io.github.hosseinkarami_dev.near.rpc.models.RpcQueryRequest
+import io.github.hosseinkarami_dev.near.rpc.models.RpcQueryResponse
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.serialization.kotlinx.json.json
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.assertNotNull
+
+class QueryTest {
+
+    private lateinit var httpClient: HttpClient
+    private lateinit var nearClient: NearClient
+
+    @BeforeTest
+    fun setup() {
+        httpClient = HttpClient(CIO) {
+            install(ContentNegotiation) {
+                json()
+            }
+        }
+
+        nearClient = NearClient(
+            httpClient = httpClient,
+            baseUrl = "https://rpc.mainnet.near.org"
+        )
+    }
+
+    @AfterTest
+    fun teardown() {
+        httpClient.close()
+    }
+
+    @Test
+    fun testStatus() = runTest {
+        val response = nearClient.query(
+            RpcQueryRequest.ViewAccountByFinality(
+                finality = Finality.FINAL,
+                accountId = AccountId("neardome2340.near"),
+                requestType = RpcQueryRequest.ViewAccountByFinality.RequestType.VIEW_ACCOUNT
+            )
+        )
+        val result = response.getResultOrNull<RpcQueryResponse>()
+        println("ViewAccountByFinality Response: $result")
+
+        assertNotNull(response !is RpcResponse.Failure)
+    }
+}
diff --git a/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/TxStatusTest.kt b/client/src/test/kotlin/io/github/hosseinkarami_dev/near/rpc/client/TxStatusTest.kt
@@ -45,10 +45,9 @@ class TxStatusTest {
         val response = nearClient.experimentalTxStatus(RpcTransactionStatusRequest.SenderAccountId(
             senderAccountId = AccountId("relay.tg"),
             txHash = CryptoHash("5FfisT8c27W2vg3AqFTX5EVKve2xV5ZUHuzr2vxYM6c2"),
-            waitUntil = TxExecutionStatus.ExecutedOptimistic
         ))
         val result = response.getResultOrNull<RpcTransactionResponse>()
-        println("Experimental Tx Status Response: $result")
-        assertTrue { response is RpcResponse.Failure }
+        println("Experimental Tx Status Response: $response")
+        assertTrue { response is RpcResponse.Success }
     }
 }
diff --git a/generator/src/main/kotlin/io/github/hosseinkarami_dev/near/rpc/generator/SerializerGenerator.kt b/generator/src/main/kotlin/io/github/hosseinkarami_dev/near/rpc/generator/SerializerGenerator.kt
@@ -1,3 +1,5 @@
+package io.github.hosseinkarami_dev.near.rpc.generator
+
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import io.github.hosseinkarami_dev.near.rpc.generator.SealedInfo
@@ -11,15 +13,14 @@ object SerializerGenerator {
     fun generateFromSealedInfos(
         sealedInfos: List<SealedInfo>,
         serializerPackage: String,
-        output: File,
-        discriminatorFields: List<String> = listOf("type", "name")
+        output: File
     ) {
         if (!output.exists()) output.mkdirs()
         if (sealedInfos.isEmpty()) return
 
         for (info in sealedInfos) {
             try {
-                val fileSpec = generateSealedClassSerializer(info, serializerPackage, discriminatorFields)
+                val fileSpec = generateSealedClassSerializer(info, serializerPackage)
                 fileSpec.writeTo(output)
             } catch (ex: Exception) {
                 System.err.println("Failed generating serializer for ${info.className}: ${ex.message}")
@@ -32,13 +33,33 @@ object SerializerGenerator {
 
     fun generateSealedClassSerializer(
         info: SealedInfo,
-        serializerPackage: String,
-        discriminatorFields: List<String> = listOf("type", "name")
+        serializerPackage: String
     ): FileSpec {
         val modelsPkg = info.packageName
         val clsName = info.className
         val serializerName = "${clsName}Serializer"
 
+        // derive discriminator candidate field names from the sealed-info itself
+        val discCandidates: List<String> = run {
+            val freq = mutableMapOf<String, Int>()
+            val nVariants = info.variants.size
+            for (v in info.variants) {
+                for (p in v.props) {
+                    val t = sanitizeType(p.type)
+                    // consider only string-like properties as possible discriminators
+                    if (t.equals("String", ignoreCase = true) || t.equals("kotlin.String", ignoreCase = true)) {
+                        freq[p.serialName] = (freq[p.serialName] ?: 0) + 1
+                    }
+                }
+            }
+            if (freq.isEmpty()) emptyList()
+            else {
+                // threshold: appear in at least half of variants
+                val threshold = (nVariants + 1) / 2
+                freq.filter { it.value >= threshold }.keys.toList()
+            }
+        }
+
         val modelClass = ClassName(modelsPkg, clsName)
         val kSerializerOfModel =
             ClassName("kotlinx.serialization", "KSerializer").parameterizedBy(modelClass)
@@ -153,9 +174,26 @@ object SerializerGenerator {
         val objBuilder = TypeSpec.objectBuilder(serializerName)
             .addSuperinterface(kSerializerOfModel)
 
+        // --- build a descriptor with one element per variant (names = serialName)
+        val descriptorInitializer = CodeBlock.builder()
+        descriptorInitializer.add(
+            "%M(%S) {\n",
+            MemberName("kotlinx.serialization.descriptors", "buildClassSerialDescriptor"),
+            "$modelsPkg.$clsName"
+        )
+        for (v in info.variants) {
+            val variantClass = ClassName(modelsPkg, clsName, v.name)
+            // produce: element("VariantSerialName", serializer<modelsPkg.ClsName.Variant>().descriptor)
+            descriptorInitializer.add(
+                "  element(%S, %L)\n",
+                v.serialName,
+                CodeBlock.of("serializer<%T>().descriptor", ClassName("kotlinx.serialization.json","JsonElement"))
+            )
+        }
+        descriptorInitializer.add("}")
         val descriptorProp = PropertySpec.builder("descriptor", serialDescriptor)
             .addModifiers(KModifier.OVERRIDE)
-            .initializer("%M(%S)", MemberName("kotlinx.serialization.descriptors", "buildClassSerialDescriptor"), "$modelsPkg.$clsName")
+            .initializer(descriptorInitializer.build())
             .build()
         objBuilder.addProperty(descriptorProp)
 
@@ -231,23 +269,14 @@ object SerializerGenerator {
         scb.addStatement("return")
         scb.endControlFlow()
 
+        // non-JSON: encode full variant serializer for each variant (descriptor elements align with variant order)
         scb.addStatement("val out = encoder.beginStructure(descriptor)")
         scb.beginControlFlow("when (value)")
         var idx = 0
         for (v in info.variants) {
-            if (v.kind == VariantInfo.Kind.OBJECT) {
-                scb.addStatement("%T.%L -> out.encodeStringElement(descriptor, %L, %S)", modelClass, v.name, idx, v.serialName)
-            } else {
-                val variantClass = ClassName(modelsPkg, clsName, v.name)
-                val p = v.props.firstOrNull()
-                if (p != null) {
-                    val ser = serializerExpressionFor(p.type, v.name)
-                    scb.addStatement("is %T -> out.encodeSerializableElement(descriptor, %L, %L, value.%L)", variantClass, idx, ser, p.name)
-                } else {
-                    val varSer = CodeBlock.of("serializer<%T>()", variantClass)
-                    scb.addStatement("is %T -> out.encodeSerializableElement(descriptor, %L, %L, value)", variantClass, idx, varSer)
-                }
-            }
+            val variantClass = ClassName(modelsPkg, clsName, v.name)
+            val varSer = CodeBlock.of("serializer<%T>()", variantClass)
+            scb.addStatement("is %T -> out.encodeSerializableElement(descriptor, %L, %L, value)", variantClass, idx, varSer)
             idx++
         }
         scb.endControlFlow()
@@ -302,7 +331,7 @@ object SerializerGenerator {
         dcb.beginControlFlow("is %T ->", ClassName("kotlinx.serialization.json", "JsonObject"))
         dcb.addStatement("val jobj = element")
 
-        // ---------- new: field-based detection ----------
+        // ---------- new: field-based detection with grouping to avoid duplicate checks ----------
         if (fieldBased) {
             dcb.addStatement("// fieldBased union: detect variant by unique field presence")
             for (v in dataVariants) {
@@ -333,6 +362,64 @@ object SerializerGenerator {
             }
         }
 
+        // --- Group variants by their required (non-nullable) keys to avoid emitting duplicated identical checks ---
+        run {
+            // build groups: Map(sortedRequiredKeysList -> List<VariantInfo>)
+            val reqGroups = mutableMapOf<List<String>, MutableList<VariantInfo>>()
+            for (v in dataVariants) {
+                val reqKeys = v.props.filter { !it.type.trim().endsWith("?") }.map { it.serialName }
+                if (reqKeys.isNotEmpty()) {
+                    val sortedKey = reqKeys.sorted()
+                    reqGroups.computeIfAbsent(sortedKey) { mutableListOf() }.add(v)
+                }
+            }
+
+            for ((reqKeys, variantsWithSameReq) in reqGroups) {
+                if (reqKeys.isEmpty()) continue
+                val reqListLiteral = reqKeys.joinToString(", ") { "\"$it\"" }
+                if (variantsWithSameReq.size == 1) {
+                    val v = variantsWithSameReq[0]
+                    dcb.beginControlFlow("if (listOf($reqListLiteral).all { jobj[it] != null })")
+                    if (v.props.size == 1 && v.props[0].name == "value") {
+                        val ser = serializerExpressionFor(v.props[0].type, v.name)
+                        dcb.addStatement("return %T(decoder.json.decodeFromJsonElement(%L, jobj[%S]!!))", ClassName(modelsPkg, clsName, v.name), ser, v.props[0].serialName)
+                    } else {
+                        val variantSerializerCb = CodeBlock.of("serializer<%T>()", ClassName(modelsPkg, clsName, v.name))
+                        dcb.addStatement("return decoder.json.decodeFromJsonElement(%L, jobj)", variantSerializerCb)
+                    }
+                    dcb.endControlFlow()
+                } else {
+                    // ambiguous group: try to disambiguate by 'type' field if present in all variants of the group
+                    val allHaveTypeField = variantsWithSameReq.all { vv -> vv.props.any { p -> p.serialName == "type" } }
+                    dcb.beginControlFlow("if (listOf($reqListLiteral).all { jobj[it] != null })")
+                    if (allHaveTypeField) {
+                        dcb.addStatement("val tfElem = jobj[%S]", "type")
+                        dcb.beginControlFlow("if (tfElem is %T)", ClassName("kotlinx.serialization.json", "JsonPrimitive"))
+                        dcb.addStatement("val tfVal = tfElem.content")
+                        dcb.beginControlFlow("when (tfVal)")
+                        for (v in variantsWithSameReq) {
+                            dcb.beginControlFlow("%S ->", v.serialName)
+                            if (v.props.size == 1 && v.props[0].name == "value") {
+                                val ser = serializerExpressionFor(v.props[0].type, v.name)
+                                dcb.addStatement("return %T(decoder.json.decodeFromJsonElement(%L, jobj[%S]!!))", ClassName(modelsPkg, clsName, v.name), ser, v.props[0].serialName)
+                            } else {
+                                val variantSerializerCb = CodeBlock.of("serializer<%T>()", ClassName(modelsPkg, clsName, v.name))
+                                dcb.addStatement("return decoder.json.decodeFromJsonElement(%L, jobj)", variantSerializerCb)
+                            }
+                            dcb.endControlFlow()
+                        }
+                        dcb.addStatement("else -> { /* not recognized by type field, fallthrough */ }")
+                        dcb.endControlFlow() // end when(tfVal)
+                        dcb.endControlFlow() // end if (tfElem is JsonPrimitive)
+                    } else {
+                        // can't disambiguate here; allow later heuristics (wrapper/flat/heuristic) to handle these cases.
+                        dcb.addStatement("// ambiguous required-keys group; skipping disambiguation here to avoid wrong decode")
+                    }
+                    dcb.endControlFlow() // end if listOf(...).all
+                }
+            }
+        }
+
         // wrapper-style with single-key
         dcb.beginControlFlow("if (jobj.size == 1)")
         dcb.addStatement("val entry = jobj.entries.first()")
@@ -377,34 +464,37 @@ object SerializerGenerator {
         dcb.endControlFlow() // end when(key)
         dcb.endControlFlow() // end if (jobj.size == 1)
 
-        // flat-style: try configured discriminators first, then heuristic fallback
+        // flat-style: try configured discriminators first (derived from sealed info), then heuristic fallback
         dcb.beginControlFlow("else")
 
-        // inject discriminator candidates (from generator param)
-        val discListLiteral = discriminatorFields.joinToString(", ") { "\"$it\"" }
-        dcb.addStatement("val discriminatorCandidates = listOf($discListLiteral)")
-
         dcb.addStatement("var typeField: String? = null")
-        // try configured candidates
-        dcb.beginControlFlow("for (cand in discriminatorCandidates)")
-        dcb.addStatement("typeField = jobj[cand]?.jsonPrimitive?.contentOrNull")
-        dcb.addStatement("if (typeField != null) break")
-        dcb.endControlFlow()
+        if (discCandidates.isNotEmpty()) {
+            val discListLiteral = discCandidates.joinToString(", ") { "\"$it\"" }
+            dcb.addStatement("val discriminatorCandidates = listOf($discListLiteral)")
+            dcb.beginControlFlow("for (cand in discriminatorCandidates)")
+            dcb.addStatement("val candElem = jobj[cand]")
+            dcb.beginControlFlow("if (candElem is %T)", ClassName("kotlinx.serialization.json", "JsonPrimitive"))
+            dcb.addStatement("typeField = candElem.contentOrNull")
+            dcb.addStatement("if (typeField != null) break")
+            dcb.endControlFlow()
+            dcb.endControlFlow()
+        }
 
         // heuristic: if still null, look for any string value matching a known variant serialName
         val variantNamesList = info.variants.joinToString(", ") { "\"${it.serialName}\"" }
         dcb.addStatement("if (typeField == null) {")
         dcb.addStatement("  val knownVariantNames = setOf($variantNamesList)")
         dcb.addStatement("  for ((k, v) in jobj.entries) {")
-        dcb.beginControlFlow("    if (v is %T && v.jsonPrimitive.isString)", ClassName("kotlinx.serialization.json", "JsonElement"))
-        dcb.addStatement("      val s = (v as %T).jsonPrimitive.content", ClassName("kotlinx.serialization.json", "JsonElement"))
+        dcb.beginControlFlow("    if (v is %T && v.isString)", ClassName("kotlinx.serialization.json", "JsonPrimitive"))
+        dcb.addStatement("      val s = v.content")
         dcb.addStatement("      if (knownVariantNames.any { it.equals(s, ignoreCase = true) }) { typeField = s; break }")
         dcb.endControlFlow()
         dcb.addStatement("  }")
         dcb.addStatement("}")
 
         // still null -> error
-        dcb.addStatement("if (typeField == null) throw %T(%S)", SerializationException::class, "Missing discriminator (one of ${discriminatorFields.joinToString("/")}) or recognizable variant in $clsName")
+        val discMsg = if (discCandidates.isNotEmpty()) "Missing discriminator (one of ${discCandidates.joinToString("/")}) or recognizable variant in $clsName" else "Missing discriminator or recognizable variant in $clsName"
+        dcb.addStatement("if (typeField == null) throw %T(%S)", SerializationException::class, discMsg)
 
         // normalize typeField for safe matching
         dcb.addStatement("val tf = typeField.trim()")
@@ -459,4 +549,4 @@ object SerializerGenerator {
         if (s.startsWith("`") && s.endsWith("`") && s.length > 1) s = s.substring(1, s.length - 1)
         return s.trim()
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,9 @@ class ExperimentalChangesInBlockTest {`
`42`	`42`	`fun testStatus() = runTest {`
`43`	`43`	`val response = nearClient.experimentalChangesInBlock(RpcStateChangesInBlockRequest.Finality(`
`44`	`44`	`Finality.FINAL))`
	`45`	`+`
`45`	`46`	`val result = response.getResultOrNull<RpcStateChangesInBlockByTypeResponse>()`
`46`		`- println("Experimental Changes In Block Response: $result")`
	`47`	`+ println("Experimental Changes In Block Response: $response")`
`47`	`48`	`assertTrue { response is RpcResponse.Success }`
`48`	`49`	`}`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,9 @@ class TxStatusTest {`
`45`	`45`	`val response = nearClient.experimentalTxStatus(RpcTransactionStatusRequest.SenderAccountId(`
`46`	`46`	`senderAccountId = AccountId("relay.tg"),`
`47`	`47`	`txHash = CryptoHash("5FfisT8c27W2vg3AqFTX5EVKve2xV5ZUHuzr2vxYM6c2"),`
`48`		`- waitUntil = TxExecutionStatus.ExecutedOptimistic`
`49`	`48`	`))`
`50`	`49`	`val result = response.getResultOrNull<RpcTransactionResponse>()`
`51`		`- println("Experimental Tx Status Response: $result")`
`52`		`- assertTrue { response is RpcResponse.Failure }`
	`50`	`+ println("Experimental Tx Status Response: $response")`
	`51`	`+ assertTrue { response is RpcResponse.Success }`
`53`	`52`	`}`
`54`	`53`	`}`