fix: auth_url handling and add timeout to once_async calls in realtime tests

- Replaced all `connection.once_async` calls with `asyncio.wait_for` to include a 5-second timeout.
- Ensures tests fail gracefully if connection isn't established within the specified timeframe.

Author: ttypic

.github/workflows/check.yml

@@ -30,6 +30,8 @@ jobs:
 
     - name: Setup poetry
       uses: abatilo/actions-poetry@v4
+      with:
+        poetry-version: '1.8.5'
 
     - name: Setup a local virtual environment
       run: |

ably/http/http.py

@@ -11,7 +11,7 @@
 from ably.http.httputils import HttpUtils
 from ably.transport.defaults import Defaults
 from ably.util.exceptions import AblyException
-from ably.util.helper import is_token_error
+from ably.util.helper import is_token_error, extract_url_params
 
 log = logging.getLogger(__name__)
 
@@ -198,11 +198,13 @@ def should_stop_retrying():
                                        self.preferred_port)
             url = urljoin(base_url, path)
 
+            (clean_url, url_params) = extract_url_params(url)
+
             request = self.__client.build_request(
                 method=method,
-                url=url,
+                url=clean_url,
                 content=body,
-                params=params,
+                params=dict(url_params, **params),
                 headers=all_headers,
                 timeout=timeout,
             )

ably/rest/auth.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
+
 import base64
-from datetime import timedelta
 import logging
 import time
-from typing import Optional, TYPE_CHECKING, Union
 import uuid
+from datetime import timedelta
+from typing import Optional, TYPE_CHECKING, Union
+
 import httpx
 
 from ably.types.options import Options
+
 if TYPE_CHECKING:
     from ably.rest.rest import AblyRest
     from ably.realtime.realtime import AblyRealtime
@@ -16,14 +19,14 @@
 from ably.types.tokendetails import TokenDetails
 from ably.types.tokenrequest import TokenRequest
 from ably.util.exceptions import AblyAuthException, AblyException, IncompatibleClientIdException
+from ably.util.helper import extract_url_params
 
 __all__ = ["Auth"]
 
 log = logging.getLogger(__name__)
 
 
 class Auth:
-
     class Method:
         BASIC = "BASIC"
         TOKEN = "TOKEN"
@@ -271,8 +274,7 @@ async def create_token_request(self, token_params: Optional[dict | str] = None,
         if capability is not None:
             token_request['capability'] = str(Capability(capability))
 
-        token_request["client_id"] = (
-            token_params.get('client_id') or self.client_id)
+        token_request["client_id"] = token_params.get('client_id') or self.client_id
 
         # Note: There is no expectation that the client
         # specifies the nonce; this is done by the library
@@ -388,17 +390,27 @@ def _random_nonce(self):
 
     async def token_request_from_auth_url(self, method: str, url: str, token_params,
                                           headers, auth_params):
+        # Extract URL parameters using utility function
+        clean_url, url_params = extract_url_params(url)
+
         body = None
         params = None
         if method == 'GET':
             body = {}
-            params = dict(auth_params, **token_params)
+            # Merge URL params, auth_params, and token_params (later params override earlier ones)
+            # we do this because httpx version has inconsistency and some versions override query params
+            # that are specified in url string
+            params = {**url_params, **auth_params, **token_params}
         elif method == 'POST':
             if isinstance(auth_params, TokenDetails):
                 auth_params = auth_params.to_dict()
-            params = {}
+            # For POST, URL params go in query string, auth_params and token_params go in body
+            params = url_params
             body = dict(auth_params, **token_params)
 
+        # Use clean URL for the request
+        url = clean_url
+
         from ably.http.http import Response
         async with httpx.AsyncClient(http2=True) as client:
             resp = await client.request(method=method, url=url, headers=headers, params=params, data=body)
@@ -420,6 +432,6 @@ async def token_request_from_auth_url(self, method: str, url: str, token_params,
             token_request = response.text
         else:
             msg = 'auth_url responded with unacceptable content-type ' + content_type + \
-                ', should be either text/plain, application/jwt or application/json',
+                  ', should be either text/plain, application/jwt or application/json',
             raise AblyAuthException(msg, 401, 40170)
         return token_request

ably/util/helper.py

@@ -3,7 +3,8 @@
 import string
 import asyncio
 import time
-from typing import Callable
+from typing import Callable, Tuple, Dict
+from urllib.parse import urlparse, parse_qs
 
 
 def get_random_id():
@@ -25,6 +26,34 @@ def is_token_error(exception):
     return 40140 <= exception.code < 40150
 
 
+def extract_url_params(url: str) -> Tuple[str, Dict[str, str]]:
+    """
+    Extract URL parameters from a URL and return a clean URL and parameters dict.
+
+    Args:
+        url: The URL to parse
+
+    Returns:
+        Tuple of (clean_url_without_params, url_params_dict)
+    """
+    parsed_url = urlparse(url)
+    url_params = {}
+
+    if parsed_url.query:
+        # Convert query parameters to a flat dictionary
+        query_params = parse_qs(parsed_url.query)
+        for key, values in query_params.items():
+            # Take the last value if multiple values exist for the same key
+            url_params[key] = values[-1]
+
+    # Reconstruct clean URL without query parameters
+    clean_url = f"{parsed_url.scheme}://{parsed_url.netloc}{parsed_url.path}"
+    if parsed_url.fragment:
+        clean_url += f"#{parsed_url.fragment}"
+
+    return clean_url, url_params
+
+
 class Timer:
     def __init__(self, timeout: float, callback: Callable):
         self._timeout = timeout