Maintain same root object when resetting the ObjectsPool

The correct behaviour wasn't clear from the spec when I wrote cb427d8,
but new spec PR [1] makes it seem that this is the right thing to do
(still needs clarifying though).

[1] ably/specification#346

Author: lawrence-forooghian

Sources/AblyLiveObjects/Internal/DefaultLiveMap.swift

@@ -287,6 +287,13 @@ internal final class InternalDefaultLiveMap: Sendable {
         }
     }
 
+    /// Resets the map's data, per RTO4b2. This is to be used when an `ATTACHED` ProtocolMessage indicates that the only object in a channel is an empty root map.
+    internal func resetData() {
+        mutex.withLock {
+            mutableState.resetData()
+        }
+    }
+
     // MARK: - Mutable state and the operations that affect it
 
     private struct MutableState {
@@ -544,6 +551,12 @@ internal final class InternalDefaultLiveMap: Sendable {
                 logger: logger,
             )
         }
+
+        /// Resets the map's data, per RTO4b2. This is to be used when an `ATTACHED` ProtocolMessage indicates that the only object in a channel is an empty root map.
+        internal mutating func resetData() {
+            // RTO4b2
+            data = [:]
+        }
     }
 
     // MARK: - Helper Methods

Sources/AblyLiveObjects/Internal/ObjectsPool.swift

@@ -209,4 +209,16 @@ internal struct ObjectsPool {
 
         logger.log("applySyncObjectsPool completed. Pool now contains \(entries.count) objects", level: .debug)
     }
+
+    /// Removes all entries except the root, and clears the root's data. This is to be used when an `ATTACHED` ProtocolMessage indicates that the only object in a channel is an empty root map, per RTO4b.
+    internal mutating func reset() {
+        let root = root
+
+        // RTO4b1
+        entries = [Self.rootKey: .map(root)]
+
+        // RTO4b2
+        // TODO: this one is unclear (are we meant to replace the root or just clear its data?) https://github.com/ably/specification/pull/333/files#r2183493458. I believe that the answer is that we should just clear its data but the spec point needs to be clearer, see https://github.com/ably/specification/pull/346/files#r2201434895.
+        root.resetData()
+    }
 }

Sources/AblyLiveObjects/InternalDefaultRealtimeObjects.swift

@@ -244,8 +244,7 @@ internal final class InternalDefaultRealtimeObjects: Sendable, LiveMapObjectPool
             }
 
             // RTO4b1, RTO4b2: Reset the ObjectsPool to have a single empty root object
-            // TODO: this one is unclear (are we meant to replace the root or just clear its data?) https://github.com/ably/specification/pull/333/files#r2183493458
-            objectsPool = .init(logger: logger)
+            objectsPool.reset()
 
             // I have, for now, not directly implemented the "perform the actions for object sync completion" of RTO4b4 since my implementation doesn't quite match the model given there; here you only have a SyncObjectsPool if you have an OBJECT_SYNC in progress, which you might not have upon receiving an ATTACHED. Instead I've just implemented what seem like the relevant side effects. Can revisit this if "the actions for object sync completion" get more complex.
 

Tests/AblyLiveObjectsTests/InternalDefaultRealtimeObjectsTests.swift

@@ -383,10 +383,10 @@ struct InternalDefaultRealtimeObjectsTests {
             #expect(newPool.entries["map:existing@123"] == nil) // Should be removed
             #expect(newPool.entries["counter:existing@456"] == nil) // Should be removed
 
-            // Verify root is a new zero-valued map (RTO4b2)
-            // TODO: this one is unclear (are we meant to replace the root or just clear its data?) https://github.com/ably/specification/pull/333/files#r2183493458
+            // Verify root is the same object, but with data cleared (RTO4b2)
+            // TODO: this one is unclear (are we meant to replace the root or just clear its data?) https://github.com/ably/specification/pull/333/files#r2183493458. I believe that the answer is that we should just clear its data but the spec point needs to be clearer, see https://github.com/ably/specification/pull/346/files#r2201434895.
             let newRoot = newPool.root
-            #expect(newRoot as AnyObject !== originalPool.root as AnyObject) // Should be a new instance
+            #expect(newRoot as AnyObject === originalPool.root as AnyObject) // Should be same instance
             #expect(newRoot.testsOnly_data.isEmpty) // Should be zero-valued (empty)
 
             // RTO4b3, RTO4b4, RTO4b5: SyncObjectsPool must be cleared, sync sequence cleared, BufferedObjectOperations cleared
@@ -410,15 +410,14 @@ struct InternalDefaultRealtimeObjectsTests {
             realtimeObjects.onChannelAttached(hasObjects: false)
             #expect(realtimeObjects.testsOnly_onChannelAttachedHasObjects == false)
             let newPool = realtimeObjects.testsOnly_objectsPool
-            #expect(newPool.root as AnyObject !== originalRoot as AnyObject)
+            #expect(newPool.root as AnyObject === originalRoot as AnyObject)
             #expect(newPool.entries.count == 1)
 
             // Third call with hasObjects = true again (should do nothing)
-            let secondResetRoot = newPool.root
             realtimeObjects.onChannelAttached(hasObjects: true)
             #expect(realtimeObjects.testsOnly_onChannelAttachedHasObjects == true)
             let finalPool = realtimeObjects.testsOnly_objectsPool
-            #expect(finalPool.root as AnyObject === secondResetRoot as AnyObject) // Should be unchanged
+            #expect(finalPool.root as AnyObject === originalRoot as AnyObject) // Should be unchanged
         }
 
         /// Test that sync sequence is properly discarded even with complex sync state