phoenix-channels-python-client 0.4.3__tar.gz → 0.4.4__tar.gz

{phoenix_channels_python_client-0.4.3/phoenix_channels_python_client.egg-info → phoenix_channels_python_client-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phoenix-channels-python-client
-Version: 0.4.3
+Version: 0.4.4
 Summary: A Python client library for connecting to Phoenix Channels
 Author: Phoenix Channels Python Client
 License-Expression: MIT

{phoenix_channels_python_client-0.4.3 → phoenix_channels_python_client-0.4.4}/phoenix_channels_python_client/__init__.py

@@ -29,7 +29,7 @@ from phoenix_channels_python_client.protocol_handler import (
 )
 from phoenix_channels_python_client.utils import setup_logging
 
-__version__ = "0.4.3"
+__version__ = "0.4.4"
 __author__ = "Phoenix Channels Python Client"
 
 __all__ = [

{phoenix_channels_python_client-0.4.3 → phoenix_channels_python_client-0.4.4}/phoenix_channels_python_client/client.py

@@ -241,7 +241,8 @@ class PHXChannelsClient(SupervisorMixin, TopicRuntimeMixin, ReconnectControllerM
 
         try:
             await self._initial_connection_future
-        except Exception:
+        except (Exception, asyncio.CancelledError):
+            # Not BaseException: awaiting cleanup on GeneratorExit raises RuntimeError.
             await self.shutdown("Initial connection failed")
             raise
 

{phoenix_channels_python_client-0.4.3 → phoenix_channels_python_client-0.4.4/phoenix_channels_python_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phoenix-channels-python-client
-Version: 0.4.3
+Version: 0.4.4
 Summary: A Python client library for connecting to Phoenix Channels
 Author: Phoenix Channels Python Client
 License-Expression: MIT

{phoenix_channels_python_client-0.4.3 → phoenix_channels_python_client-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phoenix-channels-python-client"
-version = "0.4.3"
+version = "0.4.4"
 description = "A Python client library for connecting to Phoenix Channels"
 readme = "README.md"
 license = "MIT"

{phoenix_channels_python_client-0.4.3 → phoenix_channels_python_client-0.4.4}/tests/test_shutdown_races.py

@@ -47,6 +47,9 @@ HELD_BACKOFF = derive_policy(
     FAST_RECONNECT, base_delay_s=HELD_BACKOFF_S, max_delay_s=HELD_BACKOFF_S
 )
 
+# More refusals than any test reaches, so only the client's own stop ends them.
+REFUSE_EVERY_HANDSHAKE = 1_000_000
+
 
 class HeldCallback:
     """A topic callback that, once cancelled, holds its unwinding until released.
@@ -378,3 +381,107 @@ async def test_shutdown_during_a_close_still_closes_the_socket(
             await asyncio.wait_for(client.shutdown(STOP_REASON), ASYNC_TIMEOUT_S)
 
             assert socket.state is State.CLOSED
+
+
+async def a_handshake_was_refused(server: FakePhoenixServer) -> None:
+    assert await wait_for_condition(lambda: server.refused_handshakes >= 1)
+
+
+async def expire_on_first_refusal(
+    server: FakePhoenixServer, client: PHXChannelsClient, deadline: asyncio.Timeout
+) -> asyncio.Task[None] | None:
+    """Expire ``deadline`` once a handshake was refused; return entry's supervisor."""
+    await a_handshake_was_refused(server)
+    supervisor = client._supervisor_task
+    deadline.reschedule(asyncio.get_running_loop().time())
+    return supervisor
+
+
+async def time_out_entry_on_first_refusal(
+    server: FakePhoenixServer, client: PHXChannelsClient
+) -> asyncio.Task[None] | None:
+    """Enter under a deadline that expires on the first refused handshake.
+
+    Returns the supervisor entry started; fails unless the deadline ended entry.
+    The deadline starts at ``ASYNC_TIMEOUT_S``, so a missing refusal fails here
+    instead of leaving entry waiting forever.
+    """
+    expiry: asyncio.Task[asyncio.Task[None] | None] | None = None
+    try:
+        async with asyncio.timeout(ASYNC_TIMEOUT_S) as deadline:
+            expiry = asyncio.create_task(
+                expire_on_first_refusal(server, client, deadline)
+            )
+            await client.__aenter__()
+    except TimeoutError:
+        assert expiry is not None
+        return expiry.result()
+    finally:
+        if expiry is not None:
+            expiry.cancel()
+    pytest.fail("entry ended before its deadline")
+
+
+async def test_a_timed_out_entry_stops_connecting(
+    phoenix_server: FakePhoenixServer,
+) -> None:
+    client = make_client(phoenix_server, reconnect_policy=FAST_RECONNECT)
+    try:
+        with phoenix_server.refusing(REFUSE_EVERY_HANDSHAKE):
+            supervisor = await time_out_entry_on_first_refusal(phoenix_server, client)
+
+            assert supervisor is not None
+            assert supervisor.done()
+            assert client._state is ClientState.CLOSED
+
+        async with client:  # the stopped client enters again once the server accepts
+            assert client.connection is not None
+    finally:
+        await asyncio.wait_for(client.shutdown(STOP_REASON), ASYNC_TIMEOUT_S)
+
+
+async def test_a_second_cancel_during_entry_cleanup_still_stops_connecting(
+    phoenix_server: FakePhoenixServer,
+) -> None:
+    client = make_client(phoenix_server, reconnect_policy=FAST_RECONNECT)
+    try:
+        with phoenix_server.refusing(REFUSE_EVERY_HANDSHAKE):
+            entering = asyncio.create_task(client.__aenter__())
+            await a_handshake_was_refused(phoenix_server)
+            supervisor = client._supervisor_task
+            assert supervisor is not None
+
+            entering.cancel()
+            await asyncio.sleep(0)  # the cancelled entry starts its cleanup shutdown
+            assert client._state is ClientState.SHUTTING_DOWN
+
+            entering.cancel()
+            with pytest.raises(asyncio.CancelledError):
+                await asyncio.wait_for(entering, ASYNC_TIMEOUT_S)
+
+            # Joins the cleanup the entry started; it was not abandoned.
+            await asyncio.wait_for(client.shutdown(STOP_REASON), ASYNC_TIMEOUT_S)
+            assert supervisor.done()
+            assert client._state is ClientState.CLOSED
+            assert client.connection is None
+    finally:
+        await asyncio.wait_for(client.shutdown(STOP_REASON), ASYNC_TIMEOUT_S)
+
+
+async def test_closing_a_pending_entry_is_silent(
+    phoenix_server: FakePhoenixServer,
+) -> None:
+    client = make_client(phoenix_server)
+    phoenix_server.handshake_gate.clear()
+    entry = client.__aenter__()
+    try:
+        entry.send(None)  # suspends at the initial-connection await
+        entry.close()  # raises if entry awaits while handling GeneratorExit
+    finally:
+        phoenix_server.handshake_gate.set()
+        await asyncio.wait_for(client.shutdown(STOP_REASON), ASYNC_TIMEOUT_S)
+
+    # The closed entry no longer awaits its outcome; retrieve it here.
+    initial_connection = client._initial_connection_future
+    assert initial_connection is not None
+    assert isinstance(initial_connection.exception(), PHXConnectionError)