ctrader-api-client 0.7.3__tar.gz → 0.8.0__tar.gz

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ctrader-api-client
-Version: 0.7.3
+Version: 0.8.0
 Summary: API Client to interact with the cTrader Open API spec
 Author-email: Elio <elioachukri@pm.me>
 License-File: LICENSE
@@ -354,10 +354,14 @@ config = ClientConfig(
     heartbeat_timeout=30.0, # Or 0 to disable server heartbeat checks
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection. A
+    # finite budget that runs out raises CTraderReconnectAbandonedError out
+    # of the `async with client:` block.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 
     # Token refresh: when to refresh access tokens and how hard to retry
     refresh_policy=RefreshPolicy(

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/README.md

@@ -335,10 +335,14 @@ config = ClientConfig(
     heartbeat_timeout=30.0, # Or 0 to disable server heartbeat checks
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection. A
+    # finite budget that runs out raises CTraderReconnectAbandonedError out
+    # of the `async with client:` block.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 
     # Token refresh: when to refresh access tokens and how hard to retry
     refresh_policy=RefreshPolicy(

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/docs/api/exceptions.md

@@ -153,6 +153,32 @@ other handlers for that event.
     options:
       show_source: false
 
+::: ctrader_api_client.CTraderReconnectAbandonedError
+    options:
+      show_source: false
+
+This is the one connection exception that reaches you without your having called
+anything: it is raised out of the `async with client:` block itself. Reconnection
+is unbounded by default, so seeing it means either that `reconnect_attempts` was
+set to a finite number and every one was spent, or that something failed which
+the reconnection logic did not anticipate.
+
+```python
+while True:
+    try:
+        async with client:
+            await asyncio.Event().wait()
+    except CTraderReconnectAbandonedError:
+        logger.exception("Client abandoned its connection; starting a new one")
+        await asyncio.sleep(30)
+```
+
+Catching it is only worthwhile if you intend to build a fresh client, since the
+one that raised it is finished. Letting it propagate and having a process
+supervisor restart you is an equally good answer, and the reason it is raised
+rather than logged: a client that has stopped reconnecting has no reader and no
+heartbeat left to notice anything, so nothing short of a restart brings it back.
+
 ### Authentication
 
 ::: ctrader_api_client.AuthenticationError

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/docs/getting-started.md

@@ -312,13 +312,22 @@ config = ClientConfig(
     heartbeat_timeout=0,  # 0 to disable server heartbeat checks (default)
     request_timeout=30.0,
 
-    # Reconnection
-    reconnect_attempts=5,
+    # Reconnection: None retries for as long as the client is open (the
+    # default), an integer caps the attempts, 0 disables reconnection.
+    reconnect_attempts=None,
     reconnect_min_wait=1.0,
     reconnect_max_wait=60.0,
+    connect_timeout=30.0,
 )
 ```
 
+Reconnection is unbounded by default because a finite budget that runs out
+leaves a client that can never recover: there is no reader and no heartbeat left
+to notice anything, so it stays offline until the process restarts. If you do
+set a finite `reconnect_attempts`, spending it raises
+`CTraderReconnectAbandonedError` out of the `async with client:` block rather
+than leaving the client alive and permanently disconnected.
+
 ## Next Steps
 
 - [API Reference - Client](api/client.md) - Full client documentation

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ctrader-api-client"
-version = "0.7.3"
+version = "0.8.0"
 description = "API Client to interact with the cTrader Open API spec"
 readme = "README.md"
 authors = [

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/__init__.py

@@ -92,6 +92,7 @@ from .exceptions import (
     CTraderConnectionFailedError,
     CTraderConnectionTimeoutError,
     CTraderError,
+    CTraderReconnectAbandonedError,
     DeserializationError,
     FramingError,
     ProtocolError,
@@ -139,6 +140,7 @@ __all__ = [
     "CTraderConnectionFailedError",
     "CTraderConnectionTimeoutError",
     "CTraderError",
+    "CTraderReconnectAbandonedError",
     "ClientConfig",
     "ClientDisconnectEvent",
     "CloseDetail",

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/composition.py

@@ -78,6 +78,7 @@ def build_graph(
         host=config.host,
         port=config.port,
         use_ssl=config.use_ssl,
+        connect_timeout=config.connect_timeout,
     )
     protocol = Protocol(
         transport=transport,

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/config.py

@@ -17,7 +17,12 @@ class ClientConfig(BaseModel):
         heartbeat_interval: Seconds between heartbeat sends.
         heartbeat_timeout: Seconds without server-initiated messages before disconnect. Set to 0 to disable.
         request_timeout: Default timeout for API requests in seconds.
-        reconnect_attempts: Max reconnection attempts (0 to disable).
+        connect_timeout: Seconds allowed for the TCP connection and TLS
+            handshake together, after which the attempt is failed and retried.
+        reconnect_attempts: Max reconnection attempts. None (the default)
+            retries for as long as the client is open. 0 disables reconnection.
+            A finite budget that runs out abandons the connection and raises
+            CTraderReconnectAbandonedError out of the `async with` block.
         reconnect_min_wait: Initial wait between reconnection attempts.
         reconnect_max_wait: Maximum wait between reconnection attempts.
         refresh_policy: When to refresh access tokens and how hard to try.
@@ -51,9 +56,10 @@ class ClientConfig(BaseModel):
 
     # Request settings
     request_timeout: float = Field(default=30.0, gt=0)
+    connect_timeout: float = Field(default=30.0, gt=0)
 
     # Reconnection settings
-    reconnect_attempts: int = Field(default=5, ge=0)
+    reconnect_attempts: int | None = Field(default=None, ge=0)
     reconnect_min_wait: float = Field(default=1.0, gt=0)
     reconnect_max_wait: float = Field(default=60.0, gt=0)
 

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/connection/protocol.py

@@ -12,6 +12,7 @@ from tenacity import (
     AsyncRetrying,
     retry_if_exception_type,
     stop_after_attempt,
+    stop_never,
     wait_exponential,
 )
 
@@ -29,6 +30,7 @@ from ..exceptions import (
     CTraderConnectionClosedError,
     CTraderConnectionFailedError,
     CTraderConnectionTimeoutError,
+    CTraderReconnectAbandonedError,
     FramingError,
 )
 from .listener import ConnectionListener
@@ -73,7 +75,7 @@ class Protocol:
     def __init__(
         self,
         transport: Transport,
-        reconnect_attempts: int = 5,
+        reconnect_attempts: int | None = None,
         reconnect_min_wait: float = 1.0,
         reconnect_max_wait: float = 60.0,
     ) -> None:
@@ -81,7 +83,10 @@ class Protocol:
 
         Args:
             transport: The underlying transport for sending/receiving data.
-            reconnect_attempts: Maximum reconnection attempts (0 to disable).
+            reconnect_attempts: Maximum reconnection attempts. None retries for
+                as long as the client is open, which is the default: an outage
+                that outlasts a finite budget otherwise leaves a client that
+                can never recover. 0 disables reconnection entirely.
             reconnect_min_wait: Initial wait between attempts (seconds).
             reconnect_max_wait: Maximum wait between attempts (seconds).
         """
@@ -500,6 +505,11 @@ class Protocol:
         working — reported through `handle_disconnect` as `_redo_requested`, the
         only route left once the reader has exited — is reconnected too instead
         of being stranded.
+
+        Raises:
+            CTraderReconnectAbandonedError: If reconnection is given up on. This
+                is deliberately allowed to escape into the protocol task group
+                and tear the client down: see :meth:`_abandon`.
         """
         try:
             while True:
@@ -535,18 +545,46 @@ class Protocol:
                 await self._notify_connection_lost()
         except (CTraderConnectionFailedError, CTraderConnectionClosedError) as e:
             logger.error("Reconnection failed, giving up: %s", e)
-            self._running = False
-            # Wake all pending requests so callers fail fast instead of hanging.
-            self._fail_pending("Connection lost and reconnection failed")
-        except Exception:
-            # Defensive: never let the reconnection task crash the task group.
+            self._abandon("connection lost and reconnection failed", e)
+        except Exception as e:
+            # Nothing here is expected to fail this way — the retry loop below
+            # absorbs every failure connecting — so treat it as a defect rather
+            # than a state to sit quietly in.
             logger.exception("Unexpected error while reconnecting")
-            self._running = False
-            self._fail_pending("Reconnection error")
+            self._abandon("unexpected error while reconnecting", e)
         finally:
             self._reconnecting = False
             self._redo_requested = False
 
+    def _abandon(self, reason: str, cause: BaseException) -> None:
+        """Stop the protocol and make giving up impossible to miss.
+
+        A client that has stopped reconnecting cannot recover on its own: the
+        reader has exited, the heartbeat loop returns as soon as its next write
+        fails, and `handle_disconnect` refuses everything once `_running` is
+        False. Nothing is left that could try again. Staying alive in that state
+        only means a consumer polling `is_connected` sees a link that is down
+        and assumes, reasonably and wrongly, that something is working on it.
+
+        So the failure is raised instead of recorded. It escapes into the
+        protocol task group, through the supervisor's, and out of the
+        `async with client:` block, where a process supervisor will see it.
+
+        Raises:
+            CTraderReconnectAbandonedError: Always, unless reconnection was
+                disabled by configuration, which is a choice rather than a
+                failure and keeps the previous behaviour of a client that
+                rejects further requests.
+        """
+        self._running = False
+        # Wake all pending requests so callers fail fast instead of hanging.
+        self._fail_pending(reason)
+
+        if self._reconnect_attempts == 0:
+            return
+
+        raise CTraderReconnectAbandonedError(reason, cause) from cause
+
     def _fail_pending(self, reason: str) -> None:
         """Resolve every in-flight request with a connection error."""
         for pending in self._pending.values():
@@ -556,27 +594,35 @@ class Protocol:
     async def _reconnect(self) -> None:
         """Attempt reconnection with exponential backoff.
 
+        Retries on *any* failure rather than on an enumerated set of exception
+        types. The budget exists to outlast a server that cannot be reached,
+        and an unrecognised exception is no evidence that it can be: a
+        whitelist here meant an exception nobody had thought of skipped the
+        retries entirely and went straight to being fatal.
+
         Raises:
-            CTraderConnectionClosedError: If reconnection is disabled or all attempts fail.
-            CTraderConnectionFailedError: If connection cannot be established.
+            CTraderConnectionClosedError: If reconnection is disabled.
+            CTraderConnectionFailedError: If every attempt in the budget failed.
         """
         if self._reconnect_attempts == 0:
             raise CTraderConnectionClosedError("Connection lost and reconnection disabled")
 
+        budget = "unlimited" if self._reconnect_attempts is None else self._reconnect_attempts
+
         async for attempt in AsyncRetrying(
-            stop=stop_after_attempt(self._reconnect_attempts),
+            stop=stop_never if self._reconnect_attempts is None else stop_after_attempt(self._reconnect_attempts),
             wait=wait_exponential(
                 min=self._reconnect_min_wait,
                 max=self._reconnect_max_wait,
             ),
-            retry=retry_if_exception_type(CTraderConnectionFailedError),
+            retry=retry_if_exception_type(Exception),
             reraise=True,
         ):
             with attempt:
                 logger.debug(
-                    "Reconnection attempt %d/%d",
+                    "Reconnection attempt %d/%s",
                     attempt.retry_state.attempt_number,
-                    self._reconnect_attempts,
+                    budget,
                 )
                 await self._transport.connect()
 

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/connection/transport.py

@@ -18,17 +18,21 @@ class Transport:
     Handles raw socket connections without knowledge of protobuf or message semantics.
     """
 
-    def __init__(self, host: str, port: int, use_ssl: bool = True) -> None:
+    def __init__(self, host: str, port: int, use_ssl: bool = True, connect_timeout: float = 30.0) -> None:
         """Initialize transport configuration.
 
         Args:
             host: The server hostname to connect to.
             port: The server port to connect to.
             use_ssl: Whether to use SSL/TLS encryption. Defaults to True.
+            connect_timeout: Seconds to allow for the TCP connection and the
+                TLS handshake together. Bounds the one failure mode a caller
+                cannot retry: a handshake that neither completes nor fails.
         """
         self._host = host
         self._port = port
         self._ssl = use_ssl
+        self._connect_timeout = connect_timeout
         self._stream: ByteStream | None = None
 
     @property
@@ -62,6 +66,12 @@ class Transport:
 
         If already connected, this method returns immediately.
 
+        Either returns with a usable stream or raises
+        `CTraderConnectionFailedError`. There is deliberately no third outcome:
+        anything that goes wrong on the way to a connection *is* a failure to
+        connect, whatever its type, so callers can retry on one exception
+        rather than on a list of them that has to be kept complete.
+
         Raises:
             CTraderConnectionFailedError: If connection cannot be established.
         """
@@ -69,17 +79,25 @@ class Transport:
             return  # Already connected
 
         try:
-            if self._ssl:
-                ssl_context = ssl.create_default_context()
-                self._stream = await anyio.connect_tcp(
-                    self._host,
-                    self._port,
-                    ssl_context=ssl_context,
-                    tls_standard_compatible=True,
-                )
-            else:
-                self._stream = await anyio.connect_tcp(self._host, self._port)
-        except OSError as e:
+            # Every failure is translated, not an enumerated set of them. A TLS
+            # handshake cut short by the peer surfaces as anyio's
+            # BrokenResourceError, which is not an OSError and so used to
+            # escape untranslated — past the retry loop that only knew
+            # CTraderConnectionFailedError, and into the handler that reads an
+            # unrecognised exception as fatal. Cancellation still passes
+            # through: anyio raises it from BaseException, not Exception.
+            with anyio.fail_after(self._connect_timeout):
+                if self._ssl:
+                    ssl_context = ssl.create_default_context()
+                    self._stream = await anyio.connect_tcp(
+                        self._host,
+                        self._port,
+                        ssl_context=ssl_context,
+                        tls_standard_compatible=True,
+                    )
+                else:
+                    self._stream = await anyio.connect_tcp(self._host, self._port)
+        except Exception as e:
             raise CTraderConnectionFailedError(self._host, self._port, e) from e
 
         if self._ssl:

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/src/ctrader_api_client/exceptions.py

@@ -68,6 +68,39 @@ class CTraderConnectionTimeoutError(CTraderConnectionError):
         super().__init__(f"{operation} timed out after {timeout_seconds}s")
 
 
+class CTraderReconnectAbandonedError(CTraderConnectionError):
+    """The client tried to restore a dropped link and gave up.
+
+    Raised out of the `async with client:` block, tearing the client down
+    rather than leaving it alive but permanently offline. A client that has
+    stopped reconnecting can never recover on its own — there is no reader and
+    no heartbeat left to notice anything — so the only useful thing it can do
+    is say so where a supervisor will see it.
+
+    Reaching this is not expected. Reconnection is unbounded by default, so a
+    server that stays unreachable produces retries rather than this error. It
+    means either that `reconnect_attempts` was set to a finite number and every
+    one was used, or that something went wrong that the reconnection logic did
+    not anticipate.
+
+    Not raised when reconnection is disabled outright with
+    `reconnect_attempts=0`: not reconnecting is the documented outcome there,
+    not a failure.
+
+    Attributes:
+        reason: What was being attempted when it was abandoned.
+        cause: The final underlying failure, also set as `__cause__`.
+    """
+
+    def __init__(self, reason: str, cause: BaseException | None = None) -> None:
+        self.reason = reason
+        self.cause = cause
+        message = f"Reconnection abandoned: {reason}"
+        if cause:
+            message += f" ({cause})"
+        super().__init__(message)
+
+
 # =============================================================================
 # Authentication Errors
 # =============================================================================

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/tests/behavior/connection/test_reconnection.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import logging
+import ssl
 from collections.abc import Awaitable, Callable
+from typing import Any
 
 import anyio
 import pytest
@@ -15,12 +17,64 @@ from ctrader_api_client._internal.proto import (
     ProtoOATraderRes,
 )
 from ctrader_api_client.composition import ClientGraph
+from ctrader_api_client.config import ClientConfig
 from ctrader_api_client.connection import Transport
-from ctrader_api_client.exceptions import CTraderConnectionClosedError
+from ctrader_api_client.exceptions import (
+    CTraderConnectionClosedError,
+    CTraderConnectionFailedError,
+    CTraderReconnectAbandonedError,
+)
 
 from ...harness import FakeServer, Recorder, factories
 
 
+# Everything a connection attempt has been seen to fail with, plus one thing it
+# has not. The point of the last entry is that this list can never be complete:
+# a new anyio or CPython release is free to raise something nobody here thought
+# of, and the behaviour under test has to hold for that too. Tests below are
+# parametrised over this rather than written per exception type, because a
+# guard written against one exception is exactly what let the second outage
+# through after the first was fixed.
+CONNECT_FAILURES: list[Exception] = [
+    # What a TLS handshake cut short by the peer actually raises. This is the
+    # one that took production down: not an OSError, so it escaped translation.
+    anyio.BrokenResourceError(),
+    anyio.EndOfStream(),
+    anyio.ClosedResourceError(),
+    ssl.SSLEOFError("EOF occurred in violation of protocol"),
+    ssl.SSLCertVerificationError("certificate verify failed"),
+    OSError("connection refused"),
+    TimeoutError("timed out"),
+    RuntimeError("a failure mode nobody has predicted yet"),
+]
+
+
+def failing_connect(
+    monkeypatch: pytest.MonkeyPatch,
+    failure: Exception,
+    times: int | None = 1,
+) -> None:
+    """Make the next `times` connection attempts fail with `failure`.
+
+    Patches anyio rather than `Transport.connect`, so that the transport's own
+    translation of the failure is part of what is under test. `times=None`
+    fails every attempt.
+    """
+    connect_tcp = anyio.connect_tcp
+    remaining = times
+
+    async def connect(*args: Any, **kwargs: Any) -> Any:
+        nonlocal remaining
+        if remaining is None:
+            raise failure
+        if remaining > 0:
+            remaining -= 1
+            raise failure
+        return await connect_tcp(*args, **kwargs)
+
+    monkeypatch.setattr(anyio, "connect_tcp", connect)
+
+
 @pytest.mark.usefixtures("echoing_trader")
 async def test_client_reconnects_after_the_server_drops_the_link(
     client: CTraderClient,
@@ -206,6 +260,170 @@ async def test_a_drop_reported_while_reconnecting_is_not_lost(
     assert response.ctid_trader_account_id == 12
 
 
+@pytest.mark.parametrize("failure", CONNECT_FAILURES, ids=lambda failure: type(failure).__name__)
+async def test_connecting_reports_every_failure_as_a_connection_failure(
+    failure: Exception,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """`connect()` has two outcomes, not three: a stream, or a failure to connect.
+
+    Regression guard: it used to translate only `OSError`, so anything else —
+    `BrokenResourceError` from a broken TLS handshake, in production — came out
+    as itself. Callers retry on the translated type, so an untranslated failure
+    skipped the retries and was read as fatal instead.
+    """
+    failing_connect(monkeypatch, failure)
+    transport = Transport(host="127.0.0.1", port=1, use_ssl=False)
+
+    with pytest.raises(CTraderConnectionFailedError) as raised:
+        await transport.connect()
+
+    assert raised.value.cause is failure
+    assert transport.is_connected is False
+
+
+@pytest.mark.usefixtures("echoing_trader")
+@pytest.mark.parametrize("failure", CONNECT_FAILURES, ids=lambda failure: type(failure).__name__)
+async def test_reconnection_survives_any_failure_to_connect(
+    failure: Exception,
+    make_client: Callable[..., CTraderClient],
+    connected: Callable[[CTraderClient], Awaitable[CTraderClient]],
+    server: FakeServer,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A failed connection attempt is a reason to try again, whatever it was.
+
+    Regression guard for the second production outage: a `BrokenResourceError`
+    from a TLS handshake the broker cut short went straight past a retry loop
+    that only recognised `CTraderConnectionFailedError`, and the client died on
+    attempt 1 of 5 without spending its budget. The exception type must not be
+    what decides whether the client survives, so this holds for a failure no
+    one has anticipated as much as for the one that happened.
+    """
+    client = await connected(make_client())
+    failing_connect(monkeypatch, failure)
+
+    await server.drop_connection()
+    await server.wait_for_connections(2)
+
+    response = await client.protocol.request(ProtoOATraderReq(ctid_trader_account_id=20), ProtoOATraderRes)
+
+    assert response.ctid_trader_account_id == 20
+
+
+@pytest.mark.usefixtures("echoing_trader")
+async def test_reconnection_outlasts_an_outage_longer_than_the_old_budget(
+    make_client: Callable[..., CTraderClient],
+    connected: Callable[[CTraderClient], Awaitable[CTraderClient]],
+    server: FakeServer,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Reconnection keeps going by default rather than running out.
+
+    The default used to be five attempts, roughly fifteen seconds of backoff —
+    less than a router reboot, after which the client was offline for good.
+    Eight consecutive failures here is more than that budget would have
+    survived, so this fails if the default ever becomes finite again.
+    """
+    client = await connected(make_client())
+    failing_connect(monkeypatch, anyio.BrokenResourceError(), times=8)
+
+    await server.drop_connection()
+    await server.wait_for_connections(2)
+
+    response = await client.protocol.request(ProtoOATraderReq(ctid_trader_account_id=21), ProtoOATraderRes)
+
+    assert response.ctid_trader_account_id == 21
+
+
+def test_reconnection_is_unbounded_unless_configured_otherwise() -> None:
+    """The default is stated here so changing it has to be deliberate."""
+    config = ClientConfig(client_id="id", client_secret="secret")
+
+    assert config.reconnect_attempts is None
+
+
+@pytest.mark.usefixtures("echoing_trader")
+async def test_a_connection_attempt_that_hangs_is_given_up_on_and_retried(
+    make_client: Callable[..., CTraderClient],
+    connected: Callable[[CTraderClient], Awaitable[CTraderClient]],
+    server: FakeServer,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """A handshake that never finishes is bounded, not waited on forever.
+
+    The failure with no exception at all: a TLS handshake that neither
+    completes nor fails leaves the reconnection parked on it, which looks
+    exactly like the permanent outage a raised exception used to cause and
+    leaves nothing in the log to say so.
+    """
+    client = await connected(make_client(connect_timeout=0.05))
+    connect_tcp = anyio.connect_tcp
+    hung = False
+
+    async def connect(*args: Any, **kwargs: Any) -> Any:
+        nonlocal hung
+        if not hung:
+            hung = True
+            await anyio.sleep_forever()
+        return await connect_tcp(*args, **kwargs)
+
+    monkeypatch.setattr(anyio, "connect_tcp", connect)
+
+    await server.drop_connection()
+    await server.wait_for_connections(2)
+
+    response = await client.protocol.request(ProtoOATraderReq(ctid_trader_account_id=22), ProtoOATraderRes)
+
+    assert hung
+    assert response.ctid_trader_account_id == 22
+
+
+async def test_abandoning_reconnection_raises_out_of_the_client_block(
+    make_client: Callable[..., CTraderClient],
+    server: FakeServer,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Giving up tears the client down instead of leaving it quietly offline.
+
+    A client that has stopped reconnecting cannot recover on its own, so
+    staying alive only means a consumer polling `is_connected` sees a link that
+    is down and assumes something is working on restoring it. In production
+    that assumption was logged once every few seconds for twenty-three minutes.
+    """
+    client = make_client(reconnect_attempts=2)
+
+    with pytest.raises(CTraderReconnectAbandonedError) as raised:
+        async with client:
+            failing_connect(monkeypatch, anyio.BrokenResourceError(), times=None)
+            await server.drop_connection()
+            # Park until the abandonment cancels us; the deadline turns a
+            # regression into a failure rather than a hung suite.
+            with anyio.fail_after(10):
+                await anyio.sleep_forever()
+
+    assert isinstance(raised.value.cause, CTraderConnectionFailedError)
+
+
+async def test_disabling_reconnection_does_not_tear_the_client_down(
+    make_client: Callable[..., CTraderClient],
+    connected: Callable[[CTraderClient], Awaitable[CTraderClient]],
+    server: FakeServer,
+) -> None:
+    """Not reconnecting on request is an outcome, not a failure to report.
+
+    The counterpart to the test above: abandonment is raised because the client
+    tried and could not, which is never true when it was told not to try.
+    """
+    client = await connected(make_client(reconnect_attempts=0))
+
+    await server.drop_connection()
+    await server.wait_for_disconnect()
+
+    with pytest.raises(CTraderConnectionClosedError):
+        await client.protocol.send_request(ProtoOATraderReq(ctid_trader_account_id=23), timeout=1)
+
+
 @pytest.mark.usefixtures("echoing_trader")
 async def test_a_failing_listener_does_not_block_reconnection(
     make_graph: Callable[..., ClientGraph],

{ctrader_api_client-0.7.3 → ctrader_api_client-0.8.0}/uv.lock

@@ -270,7 +270,7 @@ wheels = [
 
 [[package]]
 name = "ctrader-api-client"
-version = "0.7.3"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "anyio" },