[ECO-5338[Integration test] Added ably sandbox script

1. Added ktor http dependencies and updated kotlin tests bundle
2. Added IntegrationTest parameterized class to run tests for both msgpack and json
3. Updated LiveObjectTest extending IntegrationTest class

Author: sacOO7

gradle/libs.versions.toml

@@ -23,6 +23,7 @@ kotlin = "2.1.10"
 coroutine = "1.9.0"
 mockk = "1.13.13"
 turbine = "1.2.0"
+ktor = "3.0.1"
 jetbrains-annoations = "26.0.2"
 
 [libraries]
@@ -50,12 +51,14 @@ coroutine-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-c
 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"]
+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

@@ -3,7 +3,6 @@ import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 plugins {
     `java-library`
     alias(libs.plugins.kotlin.jvm)
-    alias(libs.plugins.test.retry)
 }
 
 repositories {
@@ -41,8 +40,8 @@ tasks.register<Test>("runLiveObjectUnitTests") {
 tasks.register<Test>("runLiveObjectIntegrationTests") {
     filter {
         includeTestsMatching("io.ably.lib.objects.integration.*")
+        exclude("**/IntegrationTest.class") // Exclude the base integration test class
     }
-    // TODO - check if we need retry mechanism for integration tests in the future
 }
 
 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/integration/LiveObjectTest.kt

@@ -1,14 +1,17 @@
 package io.ably.lib.objects.integration
 
-import org.junit.Assert.assertTrue
+import io.ably.lib.objects.integration.setup.IntegrationTest
+import kotlinx.coroutines.test.runTest
 import org.junit.Test
+import kotlin.test.assertNotNull
 
-class LiveObjectTest {
+open class LiveObjectTest : IntegrationTest() {
 
   @Test
-  fun testLiveObjectCreationIntegrationTest() {
-    // This is a placeholder for the actual test implementation.
-    // You would typically create instances of LiveObjects and perform assertions here.
-    assertTrue(true)
+  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,101 @@
+package io.ably.lib.objects.integration.setup
+
+import io.ably.lib.realtime.AblyRealtime
+import io.ably.lib.realtime.Channel
+import io.ably.lib.types.ClientOptions
+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)
+open class IntegrationTest {
+  @Parameterized.Parameter
+  lateinit var testParams: String
+
+  @JvmField
+  @Rule
+  val timeout: Timeout = Timeout.seconds(10)
+
+  private val realtimeClients = mutableMapOf<String, AblyRealtime>()
+
+  private suspend fun getRealtimeClient(clientOptions: ClientOptions): AblyRealtime {
+    clientOptions.useBinaryProtocol = testParams == "msgpack_protocol"
+    return sandbox.createRealtimeClient(clientOptions).apply {
+      ensureConnected()
+    }
+  }
+
+  /**
+   * 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.
+   */
+  suspend fun getRealtimeChannel(channelName: String, clientId: String = "client1"): Channel {
+    val client = realtimeClients.getOrPut(clientId) {
+      getRealtimeClient(ClientOptions().apply {
+          this.clientId = clientId
+          useBinaryProtocol = testParams == "msgpack_protocol"
+        })
+    }
+    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.
+   */
+  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() {
+    }
+  }
+}