Introduce RedisTestBase for integration tests using Testcontainers, add new test classes for event and request/response handling, and refactor LambdaMetafactory usage in RequestResponseBus and RedisEventBus to improve testability and maintainability.

Author: twisti-dev

build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     id("dev.slne.surf.surfapi.gradle.core") version "1.21.11+"
+//    id("dev.slne.surf.surfapi.gradle.standalone") version "1.21.11+" /* Uncomment to use tests */
 }
 
 group = "dev.slne"
@@ -9,6 +10,12 @@ version = findProperty("version") as String
 dependencies {
     // Lettuce Redis client
     implementation("io.lettuce:lettuce-core:7.2.1.RELEASE")
+
+    testImplementation(kotlin("test"))
+    testImplementation("org.testcontainers:testcontainers-junit-jupiter:2.0.3")
+    testImplementation("com.redis:testcontainers-redis:2.2.4")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
+    testImplementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
 }
 
 tasks.test {

src/main/kotlin/de/slne/redis/event/RedisEventBus.kt

@@ -198,7 +198,7 @@ class RedisEventBus internal constructor(private val api: RedisApi) {
                     continue
                 }
 
-                val eventConsumer = createRedisEventConsumer(listener, method)
+                val eventConsumer = createRedisEventConsumer(listener, method, firstParamType)
                 eventHandlers.computeIfAbsent(firstParamType) { ObjectArrayList() }
                     .add(eventConsumer)
             }
@@ -214,21 +214,28 @@ class RedisEventBus internal constructor(private val api: RedisApi) {
     private fun createRedisEventConsumer(
         listener: Any,
         method: Method,
+        eventType: Class<out RedisEvent>
     ): RedisEventConsumer {
-        val eventConsumerMethodType = MethodType.methodType(Void.TYPE, RedisEvent::class.java)
-        val handle = lookup.unreflect(method).bindTo(listener).asType(eventConsumerMethodType)
+        val listenerClass = listener.javaClass
+        val listenerLookup = MethodHandles.privateLookupIn(listenerClass, lookup)
+
+        val samMethodType = MethodType.methodType(Void.TYPE, Any::class.java)
+        val implMethod = listenerLookup.unreflect(method)
+        val instantiatedMethodType = MethodType.methodType(Void.TYPE, eventType)
+        val invokedType = MethodType.methodType(RedisEventConsumer::class.java, listenerClass)
+
 
         val callSite = LambdaMetafactory.metafactory(
-            lookup,
+            listenerLookup,
             "accept",
-            MethodType.methodType(RedisEventConsumer::class.java),
-            eventConsumerMethodType,
-            handle,
-            eventConsumerMethodType
+            invokedType,
+            samMethodType,
+            implMethod,
+            instantiatedMethodType
         )
 
         val factory = callSite.target
-        return factory.invokeExact() as RedisEventConsumer
+        return factory.invoke(listener) as RedisEventConsumer
     }
 
     /**
@@ -308,6 +315,6 @@ class RedisEventBus internal constructor(private val api: RedisApi) {
     @Suppress("unused")
     @FunctionalInterface
     private fun interface RedisEventConsumer {
-        fun accept(event: RedisEvent)
+        fun accept(event: Any)
     }
 }

src/main/kotlin/de/slne/redis/request/RequestResponseBus.kt

@@ -356,24 +356,25 @@ class RequestResponseBus internal constructor(
      * near-direct invocation performance.
      */
     private fun createRequestConsumer(instance: Any, method: Method): RequestConsumer {
-        val consumerMethodType = MethodType.methodType(Void.TYPE, RequestContext::class.java)
+        val handlerClass = instance.javaClass
+        val handlerLookup = MethodHandles.privateLookupIn(handlerClass, lookup)
 
-        val impl = lookup.unreflect(method)
-            .bindTo(instance)
-            .asType(consumerMethodType)
+        val samMethodType = MethodType.methodType(Void.TYPE, RequestContext::class.java)
+        val implMethod = handlerLookup.unreflect(method)
+        val invokedType = MethodType.methodType(RequestConsumer::class.java, handlerClass)
 
         val callSite = LambdaMetafactory.metafactory(
             lookup,
             "accept",
-            MethodType.methodType(RequestConsumer::class.java),
-            consumerMethodType,
-            impl,
-            consumerMethodType
+            invokedType,
+            samMethodType,
+            implMethod,
+            samMethodType
         )
 
         val target = callSite.target
 
-        return target.invokeExact() as RequestConsumer
+        return target.invoke(instance) as RequestConsumer
     }
 
     /**

src/test/kotlin/de/slne/redis/RedisSmokeTest.kt

@@ -0,0 +1,13 @@
+package de.slne.redis
+
+import kotlinx.coroutines.test.runTest
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+class RedisSmokeTest : RedisTestBase() {
+
+    @Test
+    fun `redis container responds to ping`() = runTest {
+        assertTrue(redisApi.isAlive())
+    }
+}

src/test/kotlin/de/slne/redis/RedisTestBase.kt

@@ -0,0 +1,37 @@
+package de.slne.redis
+
+import com.redis.testcontainers.RedisContainer
+import io.lettuce.core.RedisURI
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.testcontainers.junit.jupiter.Container
+import org.testcontainers.junit.jupiter.Testcontainers
+
+@Testcontainers
+abstract class RedisTestBase {
+    companion object {
+        @JvmStatic
+        @Container
+        val redisContainer =
+            RedisContainer(RedisContainer.DEFAULT_IMAGE_NAME.withTag(RedisContainer.DEFAULT_TAG))
+    }
+
+    lateinit var redisApi: RedisApi
+
+    @BeforeEach
+    fun setUpRedisApi() {
+        val api = RedisApi.create(RedisURI.create(redisContainer.redisURI))
+        beforeApiFreeze(api)
+        api.freezeAndConnect()
+        redisApi = api
+    }
+
+    open fun beforeApiFreeze(api: RedisApi) = Unit
+
+    @AfterEach
+    fun tearDownRedisApi() {
+        if (::redisApi.isInitialized) {
+            redisApi.disconnect()
+        }
+    }
+}

src/test/kotlin/de/slne/redis/event/RedisEventBusTest.kt

@@ -1,83 +1,43 @@
 package de.slne.redis.event
 
-import kotlinx.coroutines.runBlocking
+import de.slne.redis.RedisApi
+import de.slne.redis.RedisTestBase
+import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.Serializable
-import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.AfterEach
+import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertTrue
 
-class RedisEventTest {
-    
+class RedisEventBusTest: RedisTestBase() {
+
     @Serializable
-    data class TestEvent(val message: String, val value: Int) : RedisEvent()
-    
-    @Test
-    fun `test event creation includes timestamp`() {
-        val event = TestEvent("test", 42)
-        assertTrue(event.timestamp > 0)
-        assertTrue(event.timestamp <= System.currentTimeMillis())
-    }
-    
-    @Test
-    fun `test event properties are accessible`() {
-        val event = TestEvent("hello", 123)
-        assertEquals("hello", event.message)
-        assertEquals(123, event.value)
-    }
-}
+    data class TestEvent(val message: String) : RedisEvent()
 
-class SubscribeAnnotationTest {
-    
-    @Test
-    fun `test Subscribe annotation can be applied to methods`() {
-        val method = TestListener::class.java.getDeclaredMethod("onTestEvent", TestEvent::class.java)
-        assertTrue(method.isAnnotationPresent(OnRedisEvent::class.java))
+    override fun beforeApiFreeze(api: RedisApi) {
+        api.subscribeToEvents(TestListener)
     }
-    
-    @Serializable
-    data class TestEvent(val data: String) : RedisEvent()
-    
-    class TestListener {
-        @OnRedisEvent
-        fun onTestEvent(event: TestEvent) {
-            // Test method
-        }
+
+    @AfterEach
+    fun cleanup() {
+        TestListener.receivedEvents.clear()
     }
-}
 
-class RedisEventBusTest {
-    
-    @Serializable
-    data class TestEvent(val message: String) : RedisEvent()
-    
     @Test
-    fun `test listener registration scans Subscribe methods`() = runBlocking {
-        // This test verifies that listener registration doesn't throw exceptions
-        // Full integration testing requires a running Redis instance
-        val listener = TestListener()
-        
-        // Note: We can't fully test without a Redis connection
-        // but we can verify the API works
-        try {
-            // This will fail to connect but validates the API
-            val eventBus = RedisEventBus("redis://localhost:6379")
-            eventBus.registerListener(listener)
-            eventBus.unregisterListener(listener)
-            eventBus.close()
-        } catch (e: Exception) {
-            // Expected when Redis is not running
-            assertTrue(e.message?.contains("Unable to connect") == true || 
-                       e.message?.contains("Connection refused") == true ||
-                       e.cause?.message?.contains("Connection refused") == true)
-        }
+    fun testEventBusListenerReceivesEvent() = runTest {
+        val event = TestEvent("Hello, Event Bus!")
+        val received = redisApi.publishEvent(event).await()
+
+        assertEquals(1, received, "Event should be received by one listener")
+        assertEquals(1, TestListener.receivedEvents.size, "Listener should have received one event")
+        assertEquals(event, TestListener.receivedEvents[0], "Received event should match the published event")
     }
-    
-    class TestListener {
-        var receivedEvents = mutableListOf<TestEvent>()
-        
+
+    object TestListener {
+        val receivedEvents = mutableListOf<TestEvent>()
+
         @OnRedisEvent
         fun onTestEvent(event: TestEvent) {
             receivedEvents.add(event)
         }
     }
-}
+}

src/test/kotlin/de/slne/redis/event/RedisEventTest.kt

@@ -0,0 +1,26 @@
+package de.slne.redis.event
+
+import kotlinx.serialization.Serializable
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+
+class RedisEventTest {
+    @Serializable
+    data class TestEvent(val message: String, val value: Int) : RedisEvent()
+
+    @Test
+    fun `test event creation includes timestamp`() {
+        val event = TestEvent("test", 42)
+        assertTrue(event.timestamp > 0)
+        assertTrue(event.timestamp <= System.currentTimeMillis())
+    }
+
+    @Test
+    fun `test event properties are accessible`() {
+        val event = TestEvent("hello", 123)
+        assertEquals("hello", event.message)
+        assertEquals(123, event.value)
+    }
+}

src/test/kotlin/de/slne/redis/event/SubscribeAnnotationTest.kt

@@ -0,0 +1,25 @@
+package de.slne.redis.event
+
+import kotlinx.serialization.Serializable
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class SubscribeAnnotationTest {
+
+    @Test
+    fun `test Subscribe annotation can be applied to methods`() {
+        val method = TestListener::class.java.getDeclaredMethod("onTestEvent", TestEvent::class.java)
+        assertTrue(method.isAnnotationPresent(OnRedisEvent::class.java))
+    }
+
+    @Serializable
+    data class TestEvent(val data: String) : RedisEvent()
+
+
+    class TestListener {
+        @OnRedisEvent
+        fun onTestEvent(event: TestEvent) {
+            // Test method
+        }
+    }
+}

src/test/kotlin/de/slne/redis/request/RedisRequestTest.kt

@@ -0,0 +1,27 @@
+package de.slne.redis.request
+
+import kotlinx.serialization.Serializable
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class RedisRequestTest {
+
+    @Serializable
+    data class TestRequest(val message: String, val value: Int) : RedisRequest()
+
+    @Test
+    fun `test request creation includes timestamp`() {
+        val request = TestRequest("test", 42)
+        assertTrue(request.timestamp > 0)
+        assertTrue(request.timestamp <= System.currentTimeMillis())
+    }
+
+    @Test
+    fun `test request properties are accessible`() {
+        val request = TestRequest("hello", 123)
+        assertEquals("hello", request.message)
+        assertEquals(123, request.value)
+    }
+
+}

src/test/kotlin/de/slne/redis/request/RedisResponseTest.kt

@@ -0,0 +1,24 @@
+package de.slne.redis.request
+
+import kotlinx.serialization.Serializable
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class RedisResponseTest {
+    @Serializable
+    data class TestResponse(val data: String) : RedisResponse()
+
+    @Test
+    fun `test response creation includes timestamp`() {
+        val response = TestResponse("test data")
+        assertTrue(response.timestamp > 0)
+        assertTrue(response.timestamp <= System.currentTimeMillis())
+    }
+
+    @Test
+    fun `test response properties are accessible`() {
+        val response = TestResponse("hello world")
+        assertEquals("hello world", response.data)
+    }
+}