[ECO-5447] Replaced partial testObjectRemovalFromRoot with well simulated

testObjectDelete test

Author: sacOO7

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

@@ -6,11 +6,15 @@ import io.ably.lib.objects.*
 import io.ably.lib.objects.Binary
 import io.ably.lib.objects.integration.helpers.State
 import io.ably.lib.objects.integration.helpers.fixtures.initializeRootMap
+import io.ably.lib.objects.integration.helpers.simulateObjectDelete
 import io.ably.lib.objects.integration.setup.IntegrationTest
 import io.ably.lib.objects.size
 import io.ably.lib.objects.state.ObjectsStateEvent
 import io.ably.lib.objects.type.counter.LiveCounter
+import io.ably.lib.objects.type.livecounter.DefaultLiveCounter
+import io.ably.lib.objects.type.livemap.DefaultLiveMap
 import io.ably.lib.objects.type.map.LiveMap
+import io.ably.lib.objects.type.map.LiveMapUpdate
 import kotlinx.coroutines.test.runTest
 import org.junit.Test
 import kotlin.test.assertEquals
@@ -155,13 +159,13 @@ class DefaultLiveObjectsTest : IntegrationTest() {
   }
 
   /**
-   * Spec: RTLO4e - Tests the removal of objects from the root map.
    * Server runs periodic garbage collection (GC) to remove orphaned objects and will send
    * OBJECT_DELETE events for objects that are no longer referenced.
-   * `OBJECT_DELETE` event is not covered in the test and we only check if map entries are removed
+   * So, we simulate the deletion of an object by sending an object delete ProtocolMessage.
+   * Spec: RTLO4e
    */
   @Test
-  fun testObjectRemovalFromRoot() = runTest {
+  fun testObjectDelete() = runTest {
     val channelName = generateChannelName()
     // Initialize the root map on the channel with initial data
     restObjects.initializeRootMap(channelName)
@@ -171,19 +175,41 @@ class DefaultLiveObjectsTest : IntegrationTest() {
     assertEquals(6L, rootMap.size()) // Should have 6 entries initially
 
     // Remove the "referencedCounter" from the root map
-    assertNotNull(rootMap.get("referencedCounter")) // Access to ensure it exists before removal
+    val refCounter = rootMap.get("referencedCounter") as LiveCounter
+    assertNotNull(refCounter)
+    // Subscribe to counter updates to verify removal
+    val counterUpdates = mutableListOf<Double>()
+    refCounter.subscribe { event ->
+      counterUpdates.add(event.update.amount)
+    }
 
-    restObjects.removeMapValue(channelName, "root", "referencedCounter")
+    // Simulate the deletion of the referencedCounter object
+    channel.objects.simulateObjectDelete(channelName, refCounter as DefaultLiveCounter)
 
     assertWaiter { rootMap.size() == 5L } // Wait for the removal to complete
     assertNull(rootMap.get("referencedCounter")) // Should be null after removal
+    assertEquals(1, counterUpdates.size) // Should have received one update for deletion
+    assertEquals(20.0, counterUpdates[0]) // The update should indicate the counter was removed
 
     // Remove the "referencedMap" from the root map
-    assertNotNull(rootMap.get("referencedMap")) // Access to ensure it exists before removal
+    val referencedMap = rootMap.get("referencedMap") as LiveMap
+    assertNotNull(referencedMap)
+    // Subscribe to map updates to verify removal
+    val mapUpdates = mutableListOf<Map<String, LiveMapUpdate.Change>>()
+    referencedMap.subscribe { event ->
+      mapUpdates.add(event.update)
+    }
 
-    restObjects.removeMapValue(channelName, "root", "referencedMap")
+    // Simulate the deletion of the referencedMap object
+    channel.objects.simulateObjectDelete(channelName, referencedMap as DefaultLiveMap)
 
     assertWaiter { rootMap.size() == 4L } // Wait for the removal to complete
     assertNull(rootMap.get("referencedMap")) // Should be null after removal
+    assertEquals(1, mapUpdates.size) // Should have received one update for deletion
+
+    val updatedMap = mapUpdates.first()
+    assertEquals(1, updatedMap.size) // Should have one change
+    assertEquals("counterKey", updatedMap.keys.first()) // The change should be for the "counterKey"
+    assertEquals(LiveMapUpdate.Change.REMOVED, updatedMap.values.first()) // Should indicate removal
   }
 }

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

@@ -1,14 +1,40 @@
 package io.ably.lib.objects.integration.helpers
 
+import io.ably.lib.objects.*
 import io.ably.lib.objects.DefaultLiveObjects
+import io.ably.lib.objects.ObjectMessage
+import io.ably.lib.objects.ObjectOperation
+import io.ably.lib.objects.type.BaseLiveObject
 import io.ably.lib.objects.type.counter.LiveCounter
 import io.ably.lib.objects.type.map.LiveMap
-import io.ably.lib.objects.LiveObjects
 import io.ably.lib.objects.type.livecounter.DefaultLiveCounter
 import io.ably.lib.objects.type.livemap.DefaultLiveMap
+import io.ably.lib.types.ProtocolMessage
 
 internal val LiveMap.ObjectId get() = (this as DefaultLiveMap).objectId
 
 internal val LiveCounter.ObjectId get() = (this as DefaultLiveCounter).objectId
 
 internal val LiveObjects.State get() = (this as DefaultLiveObjects).state
+
+/**
+ * Server runs periodic garbage collection (GC) to remove orphaned objects and will send
+ * OBJECT_DELETE events for objects that are no longer referenced.
+ * So, we simulate the deletion of an object by sending a ProtocolMessage.
+ */
+internal fun LiveObjects.simulateObjectDelete(channelName: String, baseObject: BaseLiveObject) {
+  val defaultLiveObjects = this as DefaultLiveObjects
+  val existingSiteCode = baseObject.siteTimeserials.keys.first()
+  val existingSiteSerial = baseObject.siteTimeserials[existingSiteCode]!!
+
+  val deleteObjectProtoMsg = ProtocolMessage(ProtocolMessage.Action.`object`, channelName)
+  deleteObjectProtoMsg.state = arrayOf(ObjectMessage(
+    siteCode = existingSiteCode,
+    serial = existingSiteSerial + "1", // Increment serial to accept new operation
+    operation = ObjectOperation(
+      action = ObjectOperationAction.ObjectDelete,
+      objectId = baseObject.objectId,
+    )
+  ))
+  defaultLiveObjects.handle(deleteObjectProtoMsg)
+}