[ECO-5338] Liveobjects: Setup tests

.github/workflows/check.yml

@@ -19,4 +19,4 @@ jobs:
           distribution: 'temurin'
       - name: Set up Gradle
         uses: gradle/actions/setup-gradle@v3
-      - run: ./gradlew checkWithCodenarc checkstyleMain checkstyleTest runUnitTests
+      - run: ./gradlew checkWithCodenarc checkstyleMain checkstyleTest runUnitTests runLiveObjectUnitTests

.github/workflows/integration-test.yml

@@ -90,3 +90,21 @@ jobs:
         uses: gradle/actions/setup-gradle@v3
 
       - run: ./gradlew :java:testRealtimeSuite -Pokhttp
+
+  check-liveobjects:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: 'recursive'
+
+      - name: Set up the JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v3
+
+      - run: ./gradlew runLiveObjectIntegrationTests

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]

lib/src/main/java/io/ably/lib/realtime/AblyRealtime.java

@@ -48,7 +48,7 @@ public class AblyRealtime extends AblyRest {
      * <p>
      * This field is initialized only if the LiveObjects plugin is present in the classpath.
      */
-    private final LiveObjectsPlugin liveObjectsPlugin;
+    public final LiveObjectsPlugin liveObjectsPlugin;
 
     /**
      * Constructs a Realtime client object using an Ably API key or token string.
@@ -73,9 +73,7 @@ public AblyRealtime(ClientOptions options) throws AblyException {
         final InternalChannels channels = new InternalChannels();
         this.channels = channels;
 
-        liveObjectsPlugin = tryInitializeLiveObjectsPlugin();
-
-        connection = new Connection(this, channels, platformAgentProvider, liveObjectsPlugin);
+        connection = new Connection(this, channels, platformAgentProvider);
 
         if (!StringUtils.isNullOrEmpty(options.recover)) {
             RecoveryKeyContext recoveryKeyContext = RecoveryKeyContext.decode(options.recover);
@@ -85,6 +83,8 @@ public AblyRealtime(ClientOptions options) throws AblyException {
             }
         }
 
+        liveObjectsPlugin = tryInitializeLiveObjectsPlugin();
+
         if(options.autoConnect) connection.connect();
     }
 

lib/src/main/java/io/ably/lib/realtime/Connection.java

@@ -1,6 +1,5 @@
 package io.ably.lib.realtime;
 
-import io.ably.lib.objects.LiveObjectsPlugin;
 import io.ably.lib.realtime.ConnectionStateListener.ConnectionStateChange;
 import io.ably.lib.transport.ConnectionManager;
 import io.ably.lib.types.AblyException;
@@ -123,10 +122,10 @@ public void close() {
      * internal
      *****************/
 
-    Connection(AblyRealtime ably, ConnectionManager.Channels channels, PlatformAgentProvider platformAgentProvider, LiveObjectsPlugin liveObjectsPlugin) throws AblyException {
+    Connection(AblyRealtime ably, ConnectionManager.Channels channels, PlatformAgentProvider platformAgentProvider) throws AblyException {
         this.ably = ably;
         this.state = ConnectionState.initialized;
-        this.connectionManager = new ConnectionManager(ably, this, channels, platformAgentProvider, liveObjectsPlugin);
+        this.connectionManager = new ConnectionManager(ably, this, channels, platformAgentProvider);
     }
 
     public void onConnectionStateChange(ConnectionStateChange stateChange) {

lib/src/main/java/io/ably/lib/transport/ConnectionManager.java

@@ -14,7 +14,6 @@
 import io.ably.lib.debug.DebugOptions;
 import io.ably.lib.debug.DebugOptions.RawProtocolListener;
 import io.ably.lib.http.HttpHelpers;
-import io.ably.lib.objects.LiveObjectsPlugin;
 import io.ably.lib.plugins.PluginConnectionAdapter;
 import io.ably.lib.realtime.AblyRealtime;
 import io.ably.lib.realtime.Channel;
@@ -81,13 +80,6 @@ public class ConnectionManager implements ConnectListener, PluginConnectionAdapt
      */
     private boolean cleaningUpAfterEnteringTerminalState = false;
 
-    /**
-     * A nullable reference to the LiveObjects plugin.
-     * <p>
-     * This field is initialized only if the LiveObjects plugin is present in the classpath.
-     */
-    private final LiveObjectsPlugin liveObjectsPlugin;
-
     /**
      * Methods on the channels map owned by the {@link AblyRealtime} instance
      * which the {@link ConnectionManager} needs access to.
@@ -773,12 +765,11 @@ public void run() {
      * ConnectionManager
      ***********************/
 
-    public ConnectionManager(final AblyRealtime ably, final Connection connection, final Channels channels, final PlatformAgentProvider platformAgentProvider, LiveObjectsPlugin liveObjectsPlugin) throws AblyException {
+    public ConnectionManager(final AblyRealtime ably, final Connection connection, final Channels channels, final PlatformAgentProvider platformAgentProvider) throws AblyException {
         this.ably = ably;
         this.connection = connection;
         this.channels = channels;
         this.platformAgentProvider = platformAgentProvider;
-        this.liveObjectsPlugin = liveObjectsPlugin;
 
         ClientOptions options = ably.options;
         this.hosts = new Hosts(options.realtimeHost, Defaults.HOST_REALTIME, options);
@@ -1232,9 +1223,9 @@ public void onMessage(ITransport transport, ProtocolMessage message) throws Ably
                     break;
                 case object:
                 case object_sync:
-                    if (liveObjectsPlugin != null) {
+                    if (ably.liveObjectsPlugin != null) {
                         try {
-                            liveObjectsPlugin.handle(message);
+                            ably.liveObjectsPlugin.handle(message);
                         } catch (Throwable t) {
                             Log.e(TAG, "LiveObjectsPlugin threw while handling message", t);
                         }

lib/src/test/java/io/ably/lib/test/realtime/ConnectionManagerTest.java

@@ -137,7 +137,7 @@ public void connectionmanager_fallback_none_withoutconnection() throws AblyExcep
             Connection connection = Mockito.mock(Connection.class);
             final ConnectionManager.Channels channels = Mockito.mock(ConnectionManager.Channels.class);
 
-            ConnectionManager connectionManager = new ConnectionManager(ably, connection, channels, new EmptyPlatformAgentProvider(), null) {
+            ConnectionManager connectionManager = new ConnectionManager(ably, connection, channels, new EmptyPlatformAgentProvider()) {
                 @Override
                 protected boolean checkConnectivity() {
                     return false;

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,38 @@ 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.*")
+        exclude("**/UnitTest.class")
+    }
 }
 
-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,36 @@
+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,61 @@
+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
+
+open class LiveObjectTest : IntegrationTest() {
+
+  @Test
+  fun testChannelObjectGetterTest() = runTest {
+    val channelName = generateChannelName()
+    val channel = getRealtimeChannel(channelName)
+    val objects = channel.objects
+    assertNotNull(objects)
+  }
+}