fix: make queueMessages client option True by default

  - Add TO3g test verifying queueMessages defaults to true
  - Add RTL6c2 check to fail immediately when queueMessages is false
    and connection is CONNECTING/DISCONNECTED
  - Add test for publish failure on CONNECTING state with queueMessages=false

Author: ttypic

ably/realtime/connectionmanager.py

@@ -182,19 +182,31 @@ async def send_protocol_message(self, protocol_message: dict) -> None:
         Returns:
             None
         """
-        if self.state not in (ConnectionState.DISCONNECTED, ConnectionState.CONNECTING, ConnectionState.CONNECTED):
-            raise AblyException(f"ConnectionManager.send_protocol_message(): called in {self.state}", 500, 50000)
+        state_should_queue = (self.state in
+                           (ConnectionState.INITIALIZED, ConnectionState.DISCONNECTED, ConnectionState.CONNECTING))
+
+        if self.state != ConnectionState.CONNECTED and not state_should_queue:
+            raise AblyException(f"Cannot send message while connection is {self.state}", 400, 90000)
 
         pending_message = PendingMessage(protocol_message)
 
+        # RTL6c2: If queueMessages is false, fail immediately when not CONNECTED
+        if state_should_queue:
+            if pending_message.ack_required and not self.options.queue_messages:
+                raise AblyException(
+                    f"Cannot send message while connection is {self.state}, and queue_messages is false",
+                    400,
+                    90000,
+                )
+
         # Assign msgSerial to messages that need acknowledgment
         if pending_message.ack_required:
             # New message - assign fresh serial
             protocol_message['msgSerial'] = self.msg_serial
             self.pending_message_queue.push(pending_message)
             self.msg_serial += 1
 
-        if self.state in (ConnectionState.DISCONNECTED, ConnectionState.CONNECTING):
+        if state_should_queue:
             self.queued_messages.appendleft(pending_message)
             if pending_message.ack_required:
                 await pending_message.future

ably/types/options.py

@@ -26,7 +26,7 @@ def decode(self, delta: bytes, base: bytes) -> bytes:
 
 class Options(AuthOptions):
     def __init__(self, client_id=None, log_level=0, tls=True, rest_host=None, realtime_host=None, port=0,
-                 tls_port=0, use_binary_protocol=True, queue_messages=False, recover=False, environment=None,
+                 tls_port=0, use_binary_protocol=True, queue_messages=True, recover=False, environment=None,
                  http_open_timeout=None, http_request_timeout=None, realtime_request_timeout=None,
                  http_max_retry_count=None, http_max_retry_duration=None, fallback_hosts=None,
                  fallback_retry_timeout=None, disconnected_retry_timeout=None, idempotent_rest_publishing=None,

test/ably/realtime/realtimechannel_publish_test.py

@@ -285,6 +285,46 @@ async def check_disconnected():
 
         await ably.close()
 
+    async def test_publish_fails_on_connecting_when_queue_messages_false(self):
+        """RTN7d: Verify publish fails immediately when connection is CONNECTING and queueMessages=false"""
+        # Create client with queueMessages=False
+        ably = await TestApp.get_ably_realtime(
+            use_binary_protocol=self.use_binary_protocol,
+            queue_messages=False,
+            auto_connect=False
+        )
+
+        # Intercept connection to prevent it from succeeding
+        connection_manager = ably.connection.connection_manager
+
+        async def block_connection():
+            # Do nothing - prevent connection from completing
+            pass
+
+        connection_manager.connect_base = block_connection
+
+        # Start connecting
+        ably.connect()
+
+        # Wait for CONNECTING state
+        await asyncio.wait_for(ably.connection.once_async(ConnectionState.CONNECTING), timeout=5)
+        assert ably.connection.state == ConnectionState.CONNECTING
+
+        channel = ably.channels.get('test_connecting_channel')
+        # Don't attach - just try to publish directly
+
+        # Try to publish while in CONNECTING state with queueMessages=false
+        # Should fail immediately with error code 80000
+        with pytest.raises(AblyException) as exc_info:
+            await channel.publish('test_event', 'test_data')
+
+        # Verify it failed with appropriate error
+        assert exc_info.value.code == 90000
+        assert exc_info.value.status_code == 400
+        assert 'CONNECTING' in str(exc_info.value)
+
+        await ably.close()
+
     # RTN19a2 - Reset msgSerial on new connectionId
     async def test_msgserial_resets_on_new_connection_id(self):
         """RTN19a2: Verify msgSerial resets to 0 when connectionId changes"""

test/ably/realtime/realtimeconnection_test.py

@@ -460,3 +460,12 @@ def intercepted_websocket_frame(data):
         assert all(isinstance(frame, str) for frame in received_raw_websocket_frames)
 
         await ably.close()
+
+    # TO3g
+    async def test_queue_messages_defaults_to_true(self):
+        """TO3g: Verify that queueMessages client option defaults to true"""
+        ably = await TestApp.get_ably_realtime(auto_connect=False)
+
+        # TO3g: queueMessages defaults to true
+        assert ably.options.queue_messages is True
+        assert ably.connection.connection_manager.options.queue_messages is True