Version 0.6.0

Author: Mr3zee

grpc/grpc-core/src/commonMain/kotlin/kotlinx/rpc/grpc/GrpcClient.kt

@@ -12,7 +12,7 @@ import kotlinx.rpc.RpcCall
 import kotlinx.rpc.RpcClient
 import kotlinx.rpc.grpc.descriptor.GrpcClientDelegate
 import kotlinx.rpc.grpc.descriptor.GrpcServiceDescriptor
-import kotlinx.rpc.internal.utils.map.ConcurrentHashMap
+import kotlinx.rpc.internal.utils.map.RpcInternalConcurrentHashMap
 import kotlin.coroutines.CoroutineContext
 
 /**
@@ -23,7 +23,7 @@ import kotlin.coroutines.CoroutineContext
 public class GrpcClient internal constructor(private val channel: ManagedChannel) : RpcClient {
     override val coroutineContext: CoroutineContext = SupervisorJob()
 
-    private val stubs = ConcurrentHashMap<Long, GrpcClientDelegate>()
+    private val stubs = RpcInternalConcurrentHashMap<Long, GrpcClientDelegate>()
 
     override suspend fun <T> call(call: RpcCall): T {
         return call.delegate().call(call)

protobuf-plugin/build.gradle.kts

@@ -19,6 +19,7 @@ dependencies {
 
     testImplementation(projects.grpc.grpcCore)
     testImplementation(libs.coroutines.core)
+    testImplementation(libs.coroutines.test)
     testImplementation(libs.kotlin.test)
 
     testImplementation(libs.grpc.stub)

protobuf-plugin/src/main/kotlin/kotlinx/rpc/protobuf/model/NameResolver.kt

@@ -107,13 +107,16 @@ internal class NameResolver private constructor(
     }
 
     private fun resolveFromNode(start: Node, parents: List<String>, simpleName: String): ResolveResult {
+        val declarationOnlyResolve = start.fqName != FqName.Package.Root && start.fqName is FqName.Package
         var node: Node? = start
         var i = 0
         var entered = false
         while (i != parents.size) {
             node = node?.children[parents[i++]]
             if (node == null) {
                 break
+            } else if (node.fqName is FqName.Package && declarationOnlyResolve) {
+                return ResolveResult.NoResolve
             }
             entered = true
         }

protobuf-plugin/src/test/kotlin/kotlinx/rpc/protobuf/test/GrpcServerTest.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package kotlinx.rpc.protobuf.test
+
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.test.runTest
+import kotlinx.rpc.RpcServer
+import kotlinx.rpc.grpc.GrpcClient
+import kotlinx.rpc.grpc.GrpcServer
+
+abstract class GrpcServerTest {
+    private val serverMutex = Mutex()
+
+    abstract fun RpcServer.registerServices()
+
+    protected fun runGrpcTest(test: suspend (GrpcClient) -> Unit, ) = runTest {
+        serverMutex.withLock {
+            val grpcClient = GrpcClient("localhost", 8080) {
+                usePlaintext()
+            }
+
+            val grpcServer = GrpcServer(8080) {
+                registerServices()
+            }
+
+            grpcServer.start()
+            test(grpcClient)
+            grpcServer.shutdown()
+            grpcServer.awaitTermination()
+        }
+    }
+}

protobuf-plugin/src/test/kotlin/kotlinx/rpc/protobuf/test/TestPrimitiveService.kt

@@ -4,9 +4,7 @@
 
 package kotlinx.rpc.protobuf.test
 
-import kotlinx.coroutines.runBlocking
-import kotlinx.rpc.grpc.GrpcClient
-import kotlinx.rpc.grpc.GrpcServer
+import kotlinx.rpc.RpcServer
 import kotlinx.rpc.registerService
 import kotlinx.rpc.withService
 import kotlin.test.Test
@@ -18,19 +16,13 @@ class PrimitiveServiceImpl : PrimitiveService {
     }
 }
 
-class TestPrimitiveService {
-    @Test
-    fun testPrimitive(): Unit = runBlocking {
-        val grpcClient = GrpcClient("localhost", 8080) {
-            usePlaintext()
-        }
-
-        val grpcServer = GrpcServer(8080) {
-            registerService<PrimitiveService> { PrimitiveServiceImpl() }
-        }
-
-        grpcServer.start()
+class TestPrimitiveService : GrpcServerTest() {
+    override fun RpcServer.registerServices() {
+        registerService<PrimitiveService> { PrimitiveServiceImpl() }
+    }
 
+    @Test
+    fun testPrimitive(): Unit = runGrpcTest { grpcClient ->
         val service = grpcClient.withService<PrimitiveService>()
         val result = service.Echo(AllPrimitives {
             int32 = 42

protobuf-plugin/src/test/kotlin/kotlinx/rpc/protobuf/test/TestReferenceService.kt

@@ -9,6 +9,10 @@ import References
 import invoke
 import Other
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.test.runTest
+import kotlinx.rpc.RpcServer
 import kotlinx.rpc.grpc.GrpcClient
 import kotlinx.rpc.grpc.GrpcServer
 import kotlinx.rpc.registerService
@@ -36,11 +40,13 @@ class ReferenceTestServiceImpl : ReferenceTestService {
     }
 }
 
-class TestReferenceService {
-    @Test
-    fun testReferenceService()= runBlocking {
-        val grpcClient = initializeServerAndClient()
+class TestReferenceService : GrpcServerTest() {
+    override fun RpcServer.registerServices() {
+        registerService<ReferenceTestService> { ReferenceTestServiceImpl() }
+    }
 
+    @Test
+    fun testReferenceService()= runGrpcTest { grpcClient ->
         val service = grpcClient.withService<ReferenceTestService>()
         val result = service.Get(References {
             other = Other {
@@ -53,9 +59,7 @@ class TestReferenceService {
     }
 
     @Test
-    fun testEnum() = runBlocking {
-        val grpcClient = initializeServerAndClient()
-
+    fun testEnum() = runGrpcTest { grpcClient ->
         val service = grpcClient.withService<ReferenceTestService>()
         val result = service.Enum(UsingEnum {
             enum = Enum.ONE
@@ -65,9 +69,7 @@ class TestReferenceService {
     }
 
     @Test
-    fun testOptional() = runBlocking {
-        val grpcClient = initializeServerAndClient()
-
+    fun testOptional() = runGrpcTest { grpcClient ->
         val service = grpcClient.withService<ReferenceTestService>()
         val resultNotNull = service.Optional(OptionalTypes {
             name = "test"
@@ -91,17 +93,4 @@ class TestReferenceService {
         assertEquals(null, resultNullable.age)
         assertEquals(null, resultNullable.reference)
     }
-
-    private fun initializeServerAndClient(): GrpcClient {
-        val grpcClient = GrpcClient("localhost", 8080) {
-            usePlaintext()
-        }
-
-        val grpcServer = GrpcServer(8080) {
-            registerService<ReferenceTestService> { ReferenceTestServiceImpl() }
-        }
-
-        grpcServer.start()
-        return grpcClient
-    }
 }