[ECO-5338] Created tests package for liveobjects

1. Added test specific dependencies, updated junit, added mockk
2. Added test utils for mocking private classes, fields etc
3. Added IntegrationTest parameterized class along with sample test
4. Added sample unit test along with mocked realtime channel

Author: sacOO7

gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 agp = "8.5.2"
-junit = "4.12"
+junit = "4.13.2"
 gson = "2.9.0"
 msgpack = "0.8.11"
 java-websocket = "1.5.3"
@@ -21,7 +21,9 @@ okhttp = "4.12.0"
 test-retry = "1.6.0"
 kotlin = "2.1.10"
 coroutine = "1.9.0"
+mockk = "1.14.2"
 turbine = "1.2.0"
+ktor = "3.1.0"
 jetbrains-annoations = "26.0.2"
 
 [libraries]
@@ -47,12 +49,16 @@ android-retrostreams = { group = "net.sourceforge.streamsupport", name = "androi
 okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
 coroutine-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "coroutine" }
 coroutine-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutine" }
+mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
 turbine = { group = "app.cash.turbine", name = "turbine", version.ref = "turbine" }
+ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
 jetbrains = { group = "org.jetbrains", name = "annotations", version.ref = "jetbrains-annoations" }
 
 [bundles]
 common = ["msgpack", "vcdiff-core"]
 tests = ["junit", "hamcrest-all", "nanohttpd", "nanohttpd-nanolets", "nanohttpd-websocket", "mockito-core", "concurrentunit", "slf4j-simple"]
+kotlin-tests = ["junit", "mockk", "coroutine-test", "nanohttpd", "turbine", "ktor-client-cio", "ktor-client-core"]
 instrumental-android = ["android-test-runner", "android-test-rules", "dexmaker", "dexmaker-dx", "dexmaker-mockito", "android-retrostreams"]
 
 [plugins]

live-objects/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
 plugins {
     `java-library`
     alias(libs.plugins.kotlin.jvm)
@@ -9,14 +11,37 @@ repositories {
 
 dependencies {
     implementation(project(":java"))
-    testImplementation(kotlin("test"))
     implementation(libs.coroutine.core)
 
-    testImplementation(libs.coroutine.test)
+    testImplementation(kotlin("test"))
+    testImplementation(libs.bundles.kotlin.tests)
+}
+
+tasks.withType<Test>().configureEach {
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+    }
+    jvmArgs("--add-opens", "java.base/java.time=ALL-UNNAMED")
+    jvmArgs("--add-opens", "java.base/java.lang=ALL-UNNAMED")
+    beforeTest(closureOf<TestDescriptor> { logger.lifecycle("-> $this") })
+    outputs.upToDateWhen { false }
+    // Skip tests for the "release" build type so we don't run tests twice
+    if (name.lowercase().contains("release")) {
+        enabled = false
+    }
+}
+
+tasks.register<Test>("runLiveObjectUnitTests") {
+    filter {
+        includeTestsMatching("io.ably.lib.objects.unit.*")
+    }
 }
 
-tasks.test {
-    useJUnitPlatform()
+tasks.register<Test>("runLiveObjectIntegrationTests") {
+    filter {
+        includeTestsMatching("io.ably.lib.objects.integration.*")
+        exclude("**/IntegrationTest.class") // Exclude the base integration test class
+    }
 }
 
 kotlin {

live-objects/src/main/kotlin/io/ably/lib/objects/ErrorCodes.kt

@@ -0,0 +1,11 @@
+package io.ably.lib.objects
+
+internal enum class ErrorCode(public val code: Int) {
+  BadRequest(40_000),
+  InternalError(50_000),
+}
+
+internal enum class HttpStatusCode(public val code: Int) {
+  BadRequest(400),
+  InternalServerError(500),
+}

live-objects/src/main/kotlin/io/ably/lib/objects/Utils.kt

@@ -0,0 +1,35 @@
+package io.ably.lib.objects
+
+import io.ably.lib.types.AblyException
+import io.ably.lib.types.ErrorInfo
+
+internal fun ablyException(
+  errorMessage: String,
+  errorCode: ErrorCode,
+  statusCode: HttpStatusCode = HttpStatusCode.BadRequest,
+  cause: Throwable? = null,
+): AblyException {
+  val errorInfo = createErrorInfo(errorMessage, errorCode, statusCode)
+  return createAblyException(errorInfo, cause)
+}
+
+internal fun ablyException(
+  errorInfo: ErrorInfo,
+  cause: Throwable? = null,
+): AblyException = createAblyException(errorInfo, cause)
+
+private fun createErrorInfo(
+  errorMessage: String,
+  errorCode: ErrorCode,
+  statusCode: HttpStatusCode,
+) = ErrorInfo(errorMessage, statusCode.code, errorCode.code)
+
+private fun createAblyException(
+  errorInfo: ErrorInfo,
+  cause: Throwable?,
+) = cause?.let { AblyException.fromErrorInfo(it, errorInfo) }
+  ?: AblyException.fromErrorInfo(errorInfo)
+
+internal fun clientError(errorMessage: String) = ablyException(errorMessage, ErrorCode.BadRequest, HttpStatusCode.BadRequest)
+
+internal fun serverError(errorMessage: String) = ablyException(errorMessage, ErrorCode.InternalError, HttpStatusCode.InternalServerError)

live-objects/src/test/kotlin/io/ably/lib/objects/TestUtils.kt

@@ -0,0 +1,60 @@
+package io.ably.lib.objects
+
+import java.lang.reflect.Field
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+
+suspend fun assertWaiter(timeoutInMs: Long = 10_000, block: suspend () -> Boolean) {
+  withContext(Dispatchers.Default) {
+    withTimeout(timeoutInMs) {
+      do {
+        val success = block()
+        delay(100)
+      } while (!success)
+    }
+  }
+}
+
+fun Any.setPrivateField(name: String, value: Any?) {
+  val valueField = javaClass.findField(name)
+  valueField.isAccessible = true
+  valueField.set(this, value)
+}
+
+fun <T>Any.getPrivateField(name: String): T {
+  val valueField = javaClass.findField(name)
+  valueField.isAccessible = true
+  @Suppress("UNCHECKED_CAST")
+  return valueField.get(this) as T
+}
+
+private fun Class<*>.findField(name: String): Field {
+  var result = kotlin.runCatching { getDeclaredField(name) }
+  var currentClass = this
+  while (result.isFailure && currentClass.superclass != null) // stop when we got field or reached top of class hierarchy
+  {
+    currentClass = currentClass.superclass!!
+    result = kotlin.runCatching { currentClass.getDeclaredField(name) }
+  }
+  if (result.isFailure) {
+    throw result.exceptionOrNull() as Exception
+  }
+  return result.getOrNull() as Field
+}
+
+suspend fun <T> Any.invokePrivateSuspendMethod(methodName: String, vararg args: Any?): T = suspendCancellableCoroutine { cont ->
+  val suspendMethod = javaClass.declaredMethods.find { it.name == methodName }
+    ?: error("Method '$methodName' not found")
+  suspendMethod.isAccessible = true
+  suspendMethod.invoke(this, *args, cont)
+}
+
+fun <T> Any.invokePrivateMethod(methodName: String, vararg args: Any?): T {
+  val method = javaClass.declaredMethods.find { it.name == methodName }
+  method?.isAccessible = true
+  @Suppress("UNCHECKED_CAST")
+  return method?.invoke(this, *args) as T
+}

live-objects/src/test/kotlin/io/ably/lib/objects/integration/LiveObjectTest.kt

@@ -0,0 +1,17 @@
+package io.ably.lib.objects.integration
+
+import io.ably.lib.objects.integration.setup.IntegrationTest
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import kotlin.test.assertNotNull
+
+class LiveObjectTest : IntegrationTest() {
+
+  @Test
+  fun testChannelObjectGetterTest() = runTest {
+    val channelName = generateChannelName()
+    val channel = getRealtimeChannel(channelName)
+    val objects = channel.objects
+    assertNotNull(objects)
+  }
+}

live-objects/src/test/kotlin/io/ably/lib/objects/integration/setup/IntegrationTest.kt

@@ -0,0 +1,93 @@
+package io.ably.lib.objects.integration.setup
+
+import io.ably.lib.realtime.AblyRealtime
+import io.ably.lib.realtime.Channel
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.BeforeClass
+import org.junit.Rule
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import java.util.UUID
+
+@RunWith(Parameterized::class)
+abstract class IntegrationTest {
+  @Parameterized.Parameter
+  lateinit var testParams: String
+
+  @JvmField
+  @Rule
+  val timeout: Timeout = Timeout.seconds(10)
+
+  private val realtimeClients = mutableMapOf<String, AblyRealtime>()
+
+  /**
+   * Retrieves a realtime channel for the specified channel name and client ID
+   * If a client with the given clientID does not exist, a new client is created using the provided options.
+   * The channel is attached and ensured to be in the attached state before returning.
+   *
+   * @param channelName Name of the channel
+   * @param clientId The ID of the client to use or create. Defaults to "client1".
+   * @return The attached realtime channel.
+   * @throws Exception If the channel fails to attach or the client fails to connect.
+   */
+  internal suspend fun getRealtimeChannel(channelName: String, clientId: String = "client1"): Channel {
+    val client = realtimeClients.getOrPut(clientId) {
+      sandbox.createRealtimeClient {
+        this.clientId = clientId
+        useBinaryProtocol = testParams == "msgpack_protocol"
+      }. apply { ensureConnected() }
+    }
+    return client.channels.get(channelName).apply {
+      attach()
+      ensureAttached()
+    }
+  }
+
+  /**
+   * Generates a unique channel name for testing purposes.
+   * This is mainly to avoid channel name/state/history collisions across tests in same file.
+   */
+  internal fun generateChannelName(): String {
+    return "test-channel-${UUID.randomUUID()}"
+  }
+
+  @After
+  fun afterEach() {
+    for (ablyRealtime in realtimeClients.values) {
+      for ((channelName, channel) in ablyRealtime.channels.entrySet()) {
+        channel.off()
+        ablyRealtime.channels.release(channelName)
+      }
+      ablyRealtime.close()
+    }
+    realtimeClients.clear()
+  }
+
+  companion object {
+    private lateinit var sandbox: Sandbox
+
+    @JvmStatic
+    @Parameterized.Parameters(name = "{0}")
+    fun data(): Iterable<String> {
+      return listOf("msgpack_protocol", "json_protocol")
+    }
+
+    @JvmStatic
+    @BeforeClass
+    @Throws(Exception::class)
+    fun setUpBeforeClass() {
+      runBlocking {
+        sandbox = Sandbox.createInstance()
+      }
+    }
+
+    @JvmStatic
+    @AfterClass
+    @Throws(Exception::class)
+    fun tearDownAfterClass() {
+    }
+  }
+}