fix: hanging in wait_for_sync when channel DETACHED/FAILED

Author: owenpearson

ably/realtime/presencemap.py

@@ -333,7 +333,17 @@ def clear(self) -> None:
         Clear all members and reset sync state.
 
         Used when channel enters DETACHED or FAILED state (RTP5a).
+        Invokes any pending sync callbacks before clearing to ensure
+        waiting Futures are resolved and callers are not left blocked.
         """
+        # Notify any callbacks waiting for sync to complete
+        # This ensures Futures created by _wait_for_sync() are resolved
+        for callback in self._sync_complete_callbacks:
+            try:
+                callback()
+            except Exception as e:
+                self._logger.error(f"Error in sync complete callback during clear: {e}")
+
         self._map.clear()
         self._residual_members = None
         self._sync_in_progress = False

test/ably/realtime/presencemap_test.py

@@ -736,3 +736,37 @@ def test_start_sync_multiple_times(self):
         # Call start_sync again - should not reset residual
         self.presence_map.start_sync()
         assert self.presence_map._residual_members is initial_residual
+
+    def test_clear_invokes_sync_callbacks(self):
+        """
+        Test that clear() invokes pending sync callbacks to prevent hanging.
+
+        This ensures that if get() is waiting for sync and the channel
+        transitions to DETACHED/FAILED, the waiting Future is resolved
+        and the caller is not left blocked.
+        """
+        msg1 = PresenceMessage(
+            id='conn1:0:0',
+            connection_id='conn1',
+            client_id='client1',
+            action=PresenceAction.PRESENT
+        )
+
+        self.presence_map.put(msg1)
+        self.presence_map.start_sync()
+
+        # Register a callback as if _wait_for_sync() was called
+        callback_invoked = False
+
+        def sync_callback():
+            nonlocal callback_invoked
+            callback_invoked = True
+
+        self.presence_map.wait_sync(sync_callback)
+
+        # Clear should invoke the callback
+        self.presence_map.clear()
+
+        assert callback_invoked, "clear() should invoke pending sync callbacks"
+        assert not self.presence_map.sync_in_progress
+        assert len(self.presence_map.values()) == 0