Use existing self.session as http_session instead of creating a new one

Co-authored-by: lawtancool <26829131+lawtancool@users.noreply.github.com>

Author: Copilot

pyControl4/websocket.py

@@ -4,7 +4,6 @@
 
 import aiohttp
 import asyncio
-import ssl
 import socketio_v4 as socketio
 import logging
 
@@ -96,39 +95,35 @@ def __init__(
         session_no_verify_ssl: aiohttp.ClientSession = None,
         connect_callback=None,
         disconnect_callback=None,
-        ssl_context: ssl.SSLContext = None,
     ):
         """Creates a Control4 Websocket object.
 
         Parameters:
             `ip` - The IP address of the Control4 Director/Controller.
 
-            `session` - (Optional) Allows the use of an
+            `session_no_verify_ssl` - (Optional) Allows the use of an
                         `aiohttp.ClientSession` object
                         for all network requests. This
                         session will not be closed by the library.
                         If not provided, the library will open and
                         close its own `ClientSession`s as needed.
+                        This session is also passed to the underlying
+                        socketio/engineio client to avoid blocking
+                        `ssl.create_default_context()` calls inside
+                        the event loop.
 
             `connect_callback` - (Optional) A callback to be called when the
                 Websocket connection is opened or reconnected after a network
                 error.
 
             `disconnect_callback` - (Optional) A callback to be called when
                 the Websocket connection is lost due to a network error.
-
-            `ssl_context` - (Optional) A pre-created `ssl.SSLContext` object
-                to use for the WebSocket connection. Use this to avoid
-                blocking calls to `ssl.create_default_context()` inside
-                the event loop. If not provided, the library will create
-                its own SSL context internally.
         """
         self.base_url = "https://{}".format(ip)
         self.wss_url = "wss://{}".format(ip)
         self.session = session_no_verify_ssl
         self.connect_callback = connect_callback
         self.disconnect_callback = disconnect_callback
-        self.ssl_context = ssl_context
 
         self._item_callbacks = dict()
         # Initialize self._sio to None
@@ -202,13 +197,9 @@ async def sio_connect(self, director_bearer_token):
         # Disconnect previous sio object
         await self.sio_disconnect()
 
-        if self.ssl_context is not None:
-            connector = aiohttp.TCPConnector(ssl=self.ssl_context)
-            http_session = aiohttp.ClientSession(connector=connector)
-            # http_session ownership is transferred to the engineio client,
-            # which closes it in its _reset() method during disconnect.
+        if self.session is not None:
             self._sio = socketio.AsyncClient(
-                ssl_verify=False, http_session=http_session
+                ssl_verify=False, http_session=self.session
             )
         else:
             self._sio = socketio.AsyncClient(ssl_verify=False)

tests/test_websocket_ssl.py

@@ -1,33 +1,17 @@
 """Tests for SSL context passthrough in C4Websocket."""
 
-import ssl
-from unittest.mock import AsyncMock, MagicMock, patch, call
+from unittest.mock import AsyncMock, MagicMock, patch
 
-import aiohttp
 import socketio_v4
 import pytest
 
 from pyControl4.websocket import C4Websocket
 
 
-def test_default_no_ssl_context():
-    """Test that C4Websocket defaults to no ssl_context (backward compat)."""
-    ws = C4Websocket("192.168.1.1")
-    assert ws.ssl_context is None
-
-
-def test_ssl_context_stored():
-    """Test that a provided ssl_context is stored."""
-    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-    ctx.check_hostname = False
-    ctx.verify_mode = ssl.CERT_NONE
-    ws = C4Websocket("192.168.1.1", ssl_context=ctx)
-    assert ws.ssl_context is ctx
-
-
 @pytest.mark.asyncio
-async def test_sio_connect_without_ssl_context():
-    """Test that sio_connect uses ssl_verify=False when no ssl_context."""
+async def test_sio_connect_without_session():
+    """Test that sio_connect uses ssl_verify=False without http_session when
+    no session is provided."""
     ws = C4Websocket("192.168.1.1")
     with patch.object(
         socketio_v4.AsyncClient, "__init__", return_value=None
@@ -41,29 +25,16 @@ async def test_sio_connect_without_ssl_context():
 
 
 @pytest.mark.asyncio
-async def test_sio_connect_with_ssl_context():
-    """Test that sio_connect uses ssl_verify=False and http_session when
-    ssl_context is provided."""
-    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-    ctx.check_hostname = False
-    ctx.verify_mode = ssl.CERT_NONE
-    ws = C4Websocket("192.168.1.1", ssl_context=ctx)
+async def test_sio_connect_with_session():
+    """Test that sio_connect passes the caller's session as http_session."""
+    mock_session = MagicMock()
+    ws = C4Websocket("192.168.1.1", session_no_verify_ssl=mock_session)
     with patch.object(
         socketio_v4.AsyncClient, "__init__", return_value=None
     ) as mock_init, patch.object(
         socketio_v4.AsyncClient, "register_namespace"
     ), patch.object(
         socketio_v4.AsyncClient, "connect", new_callable=AsyncMock
-    ), patch.object(
-        aiohttp, "TCPConnector"
-    ) as mock_connector_cls, patch.object(
-        aiohttp, "ClientSession"
-    ) as mock_session_cls:
-        mock_conn = MagicMock()
-        mock_connector_cls.return_value = mock_conn
-        mock_sess = MagicMock()
-        mock_session_cls.return_value = mock_sess
+    ):
         await ws.sio_connect("test-token")
-        mock_connector_cls.assert_called_once_with(ssl=ctx)
-        mock_session_cls.assert_called_once_with(connector=mock_conn)
-        mock_init.assert_called_once_with(ssl_verify=False, http_session=mock_sess)
+        mock_init.assert_called_once_with(ssl_verify=False, http_session=mock_session)