python-engineio 4.14.0__tar.gz → 4.15.0__tar.gz

{python_engineio-4.14.0/src/python_engineio.egg-info → python_engineio-4.15.0}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: python-engineio
-Version: 4.14.0
+Version: 4.15.0
 Summary: Engine.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
-License: MIT
-Project-URL: homepage, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
-Project-URL: documentation, https://python-engineio.readthedocs.io/
-Project-URL: repository, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
-Project-URL: issues, https://github.com/miguelgrinberg/python-engineio/issues
-Project-URL: changelog, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md
+License-Expression: MIT
+Project-URL: Homepage, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
+Project-URL: Documentation, https://python-engineio.readthedocs.io/
+Project-URL: Source Code, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
+Project-URL: Issue Tracker, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/issues
+Project-URL: Changelog, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md
+Project-URL: Funding, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio#sponsor-this-project
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{python_engineio-4.14.0 → python_engineio-4.15.0}/pyproject.toml

@@ -1,7 +1,6 @@
 [project]
 name = "python-engineio"
-version = "4.14.0"
-license = {text = "MIT"}
+version = "4.15.0"
 authors = [{name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com"}]
 description = "Engine.IO server and client for Python"
 classifiers = [
@@ -10,6 +9,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
 ]
+license = "MIT"
 requires-python = ">=3.8"
 dependencies = ["simple-websocket >= 0.10.0"]
 
@@ -18,11 +18,12 @@ file = "README.md"
 content-type = "text/markdown"
 
 [project.urls]
-homepage = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio"
-documentation = "https://python-engineio.readthedocs.io/"
-repository = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio"
-issues = "https://github.com/miguelgrinberg/python-engineio/issues"
-changelog = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md"
+Homepage = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio"
+Documentation = "https://python-engineio.readthedocs.io/"
+"Source Code" = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio"
+"Issue Tracker" = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/issues"
+Changelog = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md"
+Funding = "https://code.miguelgrinberg.com/miguelgrinberg/python-engineio#sponsor-this-project"
 
 [project.optional-dependencies]
 client = [

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/async_client.py

@@ -226,6 +226,7 @@ class AsyncClient(base_client.BaseClient):
         if not self.external_http:  # pragma: no cover
             if self.http and not self.http.closed:
                 await self.http.close()
+                self.http = None
 
     def __del__(self):  # pragma: no cover
         # try to close the aiohttp session if it is still open
@@ -323,8 +324,13 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info(
                 'Attempting WebSocket connection to ' + websocket_url)
 
-        if self.http is None or self.http.closed:  # pragma: no cover
-            self.http = aiohttp.ClientSession()
+        if self.http is None or self.http.closed:
+            if self.http_factory:
+                self.http = self.http_factory()
+                if inspect.iscoroutine(self.http):
+                    self.http = await self.http
+            else:
+                self.http = aiohttp.ClientSession()
 
         # extract any new cookies passed in a header so that they can also be
         # sent the the WebSocket route
@@ -458,12 +464,17 @@ class AsyncClient(base_client.BaseClient):
 
     async def _send_request(
             self, method, url, headers=None, body=None,
-            timeout=None):  # pragma: no cover
+            timeout=None):
         if self.http is None or self.http.closed:
-            self.http = aiohttp.ClientSession()
+            if self.http_factory:
+                self.http = self.http_factory()
+                if inspect.iscoroutine(self.http):
+                    self.http = await self.http
+            else:
+                self.http = aiohttp.ClientSession()
         http_method = getattr(self.http, method.lower())
 
-        try:
+        try:  # pragma: no cover
             if not self.ssl_verify:
                 return await http_method(
                     url, headers=headers, data=body,
@@ -473,7 +484,8 @@ class AsyncClient(base_client.BaseClient):
                     url, headers=headers, data=body,
                     timeout=aiohttp.ClientTimeout(total=timeout))
 
-        except (aiohttp.ClientError, asyncio.TimeoutError) as exc:
+        except (aiohttp.ClientError, asyncio.TimeoutError) \
+                as exc:  # pragma: no cover
             self.logger.info('HTTP %s request to %s failed with error %s.',
                              method, url, exc)
             return str(exc)

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/async_server.py

@@ -298,7 +298,13 @@ class AsyncServer(base_server.BaseServer):
                         self._log_error_once(f'{e} {sid}', 'bad-sid')
                         r = self._bad_request(f'{e} {sid}')
                     else:
-                        if self.transport(sid) != transport and \
+                        if socket.upgraded:
+                            # cannot accept HTTP requests once upgraded
+                            self._log_error_once(
+                                f'Unexpected HTTP request for session {sid}',
+                                'unexpected-http')
+                            r = self._bad_request('Unexpected HTTP request')
+                        elif transport != 'polling' and \
                                 transport != upgrade_header:
                             self._log_error_once(
                                 f'Invalid transport for session {sid}',
@@ -326,18 +332,25 @@ class AsyncServer(base_server.BaseServer):
                 r = self._bad_request(f'Invalid session {sid}')
             else:
                 socket = self._get_socket(sid)
-                try:
-                    await socket.handle_post_request(environ)
-                    r = self._ok(jsonp_index=jsonp_index)
-                except exceptions.EngineIOError:
-                    if sid in self.sockets:  # pragma: no cover
-                        await self.disconnect(sid)
-                    r = self._bad_request()
-                except:  # pragma: no cover
-                    # for any other unexpected errors, we log the error
-                    # and keep going
-                    self.logger.exception('post request handler error')
-                    r = self._ok(jsonp_index=jsonp_index)
+                if not socket.upgraded:
+                    try:
+                        await socket.handle_post_request(environ)
+                        r = self._ok(jsonp_index=jsonp_index)
+                    except exceptions.EngineIOError:
+                        if sid in self.sockets:  # pragma: no cover
+                            await self.disconnect(sid)
+                            r = self._bad_request()
+                    except:  # pragma: no cover
+                        # for any other unexpected errors, we log the error
+                        # and keep going
+                        self.logger.exception('post request handler error')
+                        r = self._ok(jsonp_index=jsonp_index)
+                else:
+                    # cannot accept HTTP requests once upgraded
+                    self._log_error_once(
+                        f'Unexpected HTTP request for session {sid}',
+                        'unexpected-http')
+                    r = self._bad_request('Unexpected HTTP request')
         elif method == 'OPTIONS':
             r = self._ok()
         else:

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/base_client.py

@@ -55,8 +55,14 @@ class BaseClient:
         self.upgrades = None
         self.ping_interval = None
         self.ping_timeout = None
-        self.http = http_session
-        self.external_http = http_session is not None
+        self.http = None
+        self.http_factory = None
+        if http_session is not None:
+            if callable(http_session):
+                self.http_factory = http_session
+            else:
+                self.http = http_session
+        self.external_http = self.http is not None
         self.handle_sigint = handle_sigint
         self.ws = None
         self.read_loop_task = None

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/client.py

@@ -183,6 +183,8 @@ class Client(base_client.BaseClient):
                 self.queue.task_done()
             except self.queue_empty:
                 break
+        if not self.external_http:  # pragma: no cover
+            self.http = None
 
     def _connect_polling(self, url, headers, engineio_path):
         """Establish a long-polling connection to the Engine.IO server."""
@@ -274,6 +276,8 @@ class Client(base_client.BaseClient):
         # so that they are preserved when connecting to the WebSocket route
         cookies = None
         extra_options = {}
+        if self.http is None and self.http_factory:
+            self.http = self.http_factory()
         if self.http:
             # cookies
             ck = SimpleCookie()
@@ -458,7 +462,10 @@ class Client(base_client.BaseClient):
             self, method, url, headers=None, body=None,
             timeout=None):  # pragma: no cover
         if self.http is None:
-            self.http = requests.Session()
+            if self.http_factory:
+                self.http = self.http_factory()
+            else:
+                self.http = requests.Session()
         if not self.ssl_verify:
             self.http.verify = False
         try:

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/server.py

@@ -276,7 +276,13 @@ class Server(base_server.BaseServer):
                         self._log_error_once(f'{e} {sid}', 'bad-sid')
                         r = self._bad_request(f'{e} {sid}')
                     else:
-                        if self.transport(sid) != transport and \
+                        if socket.upgraded:
+                            # cannot accept HTTP requests once upgraded
+                            self._log_error_once(
+                                f'Unexpected HTTP request for session {sid}',
+                                'unexpected-http')
+                            r = self._bad_request('Unexpected HTTP request')
+                        elif transport != 'polling' and \
                                 transport != upgrade_header:
                             self._log_error_once(
                                 f'Invalid transport for session {sid}',
@@ -304,18 +310,25 @@ class Server(base_server.BaseServer):
                 r = self._bad_request(f'Invalid session {sid}')
             else:
                 socket = self._get_socket(sid)
-                try:
-                    socket.handle_post_request(environ)
-                    r = self._ok(jsonp_index=jsonp_index)
-                except exceptions.EngineIOError:
-                    if sid in self.sockets:  # pragma: no cover
-                        self.disconnect(sid)
-                    r = self._bad_request()
-                except:  # pragma: no cover
-                    # for any other unexpected errors, we log the error
-                    # and keep going
-                    self.logger.exception('post request handler error')
-                    r = self._ok(jsonp_index=jsonp_index)
+                if not socket.upgraded:
+                    try:
+                        socket.handle_post_request(environ)
+                        r = self._ok(jsonp_index=jsonp_index)
+                    except exceptions.EngineIOError:
+                        if sid in self.sockets:  # pragma: no cover
+                            self.disconnect(sid)
+                        r = self._bad_request()
+                    except:  # pragma: no cover
+                        # for any other unexpected errors, we log the error
+                        # and keep going
+                        self.logger.exception('post request handler error')
+                        r = self._ok(jsonp_index=jsonp_index)
+                else:
+                    # cannot accept HTTP requests once upgraded
+                    self._log_error_once(
+                        f'Unexpected HTTP request for session {sid}',
+                        'unexpected-http')
+                    r = self._bad_request('Unexpected HTTP request')
         elif method == 'OPTIONS':
             r = self._ok()
         else:

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/engineio/static_files.py

@@ -35,6 +35,8 @@ def get_static_file(path, static_files):
             elif path + '/' in static_files:
                 f = static_files[path + '/']
                 break
+    if '../' in extra_path:
+        return None
     if f:
         if isinstance(f, str):
             f = {'filename': f}

{python_engineio-4.14.0 → python_engineio-4.15.0/src/python_engineio.egg-info}/PKG-INFO

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: python-engineio
-Version: 4.14.0
+Version: 4.15.0
 Summary: Engine.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
-License: MIT
-Project-URL: homepage, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
-Project-URL: documentation, https://python-engineio.readthedocs.io/
-Project-URL: repository, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
-Project-URL: issues, https://github.com/miguelgrinberg/python-engineio/issues
-Project-URL: changelog, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md
+License-Expression: MIT
+Project-URL: Homepage, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
+Project-URL: Documentation, https://python-engineio.readthedocs.io/
+Project-URL: Source Code, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio
+Project-URL: Issue Tracker, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/issues
+Project-URL: Changelog, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio/src/branch/main/CHANGES.md
+Project-URL: Funding, https://code.miguelgrinberg.com/miguelgrinberg/python-engineio#sponsor-this-project
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{python_engineio-4.14.0 → python_engineio-4.15.0}/src/python_engineio.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/python_engineio.egg-info/dependency_links.txt
 src/python_engineio.egg-info/not-zip-safe
 src/python_engineio.egg-info/requires.txt
 src/python_engineio.egg-info/top_level.txt
+tests/async/.test_client.py.swp
 tests/async/__init__.py
 tests/async/index.html
 tests/async/test_aiohttp.py

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/async/test_asgi.py

@@ -147,6 +147,8 @@ class TestAsgi:
                          'Not Found')
         await check_path('/bar/foo', 404, 'text/plain', 'Not Found')
         await check_path('', 404, 'text/plain', 'Not Found')
+        await check_path('/static/../../LICENSE', 404, 'text/plain',
+                         'Not Found')
 
         app.static_files[''] = 'index.html'
         await check_path('/static/test/', 200, 'text/html', '<html></html>\n')

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/async/test_client.py

@@ -133,16 +133,60 @@ class TestAsyncClient:
                            match='Connect handler failed: Failed on purpose'):
             await c.connect('http://foo')
 
-    @mock.patch('engineio.client.time.time', return_value=123.456)
-    @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
-                new=mock_ws_timeout)
-    async def test_connect_websocket_handler_failure(self, _time):
+    @mock.patch('engineio.async_client.aiohttp.ClientSession')
+    async def test_connect_websocket_default_session(self, _session):
+        _session().ws_connect = mock.AsyncMock()
+        ws = _session().ws_connect.return_value
+        ws.receive = mock.AsyncMock()
+        ws.receive.return_value.data = packet.Packet(
+            packet.MESSAGE,  # invaid on purpose
+            {},
+        ).encode()
         c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
+        with pytest.raises(exceptions.ConnectionError,
+                           match='no OPEN packet'):
+            await c.connect('http://foo', transports='websocket')
+
+    async def test_connect_websocket_external_session(self):
+        c = async_client.AsyncClient()
+        c.http = mock.Mock(closed=False)
+        c.external_http = True
         c.http.ws_connect = mock.AsyncMock()
-        c.http.close = mock.AsyncMock()
         ws = c.http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
+        ws.receive.return_value.data = packet.Packet(
+            packet.MESSAGE,  # invaid on purpose
+            {},
+        ).encode()
+        with pytest.raises(exceptions.ConnectionError,
+                           match='no OPEN packet'):
+            await c.connect('http://foo', transports='websocket')
+
+    async def test_connect_websocket_async_session_factory(self):
+        async def get_session():
+            http = mock.MagicMock(closed=False)
+            http.ws_connect = mock.AsyncMock()
+            http.close = mock.AsyncMock()
+            ws = http.ws_connect.return_value
+            ws.receive = mock.AsyncMock()
+            ws.receive.return_value.data = packet.Packet(
+                packet.MESSAGE,  # invaid on purpose
+                {},
+            ).encode()
+            return http
+
+        c = async_client.AsyncClient(http_session=get_session)
+        with pytest.raises(exceptions.ConnectionError,
+                           match='no OPEN packet'):
+            await c.connect('http://foo', transports='websocket')
+
+    @mock.patch('engineio.client.time.time', return_value=123.456)
+    async def test_connect_websocket_handler_failure(self, _time):
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        http.close = mock.AsyncMock()
+        ws = http.ws_connect.return_value
+        ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
             {
@@ -152,6 +196,7 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
+        c = async_client.AsyncClient(http_session=lambda: http)
 
         @c.on('connect')
         def connect():
@@ -161,6 +206,41 @@ class TestAsyncClient:
                            match='Connect handler failed: Failed on purpose'):
             await c.connect('http://foo', transports='websocket')
 
+    @mock.patch('engineio.async_client.aiohttp.ClientSession')
+    async def test_send_request_with_default_session(self, _session):
+        _session().get = mock.AsyncMock()
+        c = async_client.AsyncClient()
+        await c._send_request('GET', '/socket.io')
+        _session().get.assert_awaited_once()
+
+    async def test_send_request_with_session_factory(self):
+        http = mock.Mock()
+        http.closed = False
+        http.get = mock.AsyncMock()
+        c = async_client.AsyncClient(http_session=lambda: http)
+        await c._send_request('GET', '/socket.io')
+        http.get.assert_awaited_once()
+
+    async def test_send_request_with_async_session_factory(self):
+        async def get_session():
+            http = mock.Mock()
+            http.closed = False
+            http.get = mock.AsyncMock()
+            return http
+
+        c = async_client.AsyncClient(http_session=get_session)
+        await c._send_request('GET', '/socket.io')
+        c.http.get.assert_awaited_once()
+
+    async def test_send_request_with_external_session(self):
+        c = async_client.AsyncClient()
+        c.http = mock.Mock()
+        c.http.closed = False
+        c.http.get = mock.AsyncMock()
+        c.external_http = True
+        await c._send_request('GET', '/socket.io')
+        c.http.get.assert_awaited_once()
+
     async def test_wait(self):
         c = async_client.AsyncClient()
         done = []
@@ -563,18 +643,18 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_connection_failed(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock(
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock(
             side_effect=[aiohttp.client_exceptions.ServerConnectionError()]
         )
+        c = async_client.AsyncClient(http_session=lambda: http)
         with pytest.raises(exceptions.ConnectionError):
             await c.connect(
                 'http://foo',
                 transports=['websocket'],
                 headers={'Foo': 'Bar'},
             )
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={'Foo': 'Bar'},
             timeout=5
@@ -582,21 +662,24 @@ class TestAsyncClient:
 
     @mock.patch('engineio.client.time.time', return_value=123.456)
     async def test_websocket_connection_extra(self, _time):
-        c = async_client.AsyncClient(websocket_extra_options={
-            'headers': {'Baz': 'Qux'},
-            'timeout': 10
-        })
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock(
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock(
             side_effect=[aiohttp.client_exceptions.ServerConnectionError()]
         )
+        c = async_client.AsyncClient(
+            http_session=lambda: http,
+            websocket_extra_options={
+                'headers': {'Baz': 'Qux'},
+                'timeout': 10
+            }
+        )
         with pytest.raises(exceptions.ConnectionError):
             await c.connect(
                 'http://foo',
                 transports=['websocket'],
                 headers={'Foo': 'Bar'},
             )
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={'Foo': 'Bar', 'Baz': 'Qux'},
             timeout=10,
@@ -606,28 +689,28 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_upgrade_failed(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock(
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock(
             side_effect=[aiohttp.client_exceptions.ServerConnectionError()]
         )
+        c = async_client.AsyncClient(http_session=lambda: http)
         c.sid = '123'
         assert not await c.connect('http://foo', transports=['websocket'])
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&sid=123&t=123.456',
             headers={},
             timeout=5,
         )
 
     async def test_websocket_connection_no_open_packet(self):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.CLOSE
         ).encode()
+        c = async_client.AsyncClient(http_session=lambda: http)
         with pytest.raises(exceptions.ConnectionError):
             await c.connect('http://foo', transports=['websocket'])
 
@@ -635,10 +718,9 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_connection_successful(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -649,6 +731,7 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
+        c = async_client.AsyncClient(http_session=lambda: http)
         c._read_loop_polling = mock.AsyncMock()
         c._read_loop_websocket = mock.AsyncMock()
         c._write_loop = mock.AsyncMock()
@@ -668,7 +751,7 @@ class TestAsyncClient:
         assert c.upgrades == []
         assert c.transport() == 'websocket'
         assert c.ws == ws
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={},
             timeout=5,
@@ -676,10 +759,9 @@ class TestAsyncClient:
 
     @mock.patch('engineio.client.time.time', return_value=123.456)
     async def test_websocket_https_noverify_connection_successful(self, _time):
-        c = async_client.AsyncClient(ssl_verify=False)
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -690,6 +772,8 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
+        c = async_client.AsyncClient(
+            http_session=lambda: http, ssl_verify=False)
         c._read_loop_polling = mock.AsyncMock()
         c._read_loop_websocket = mock.AsyncMock()
         c._write_loop = mock.AsyncMock()
@@ -709,7 +793,7 @@ class TestAsyncClient:
         assert c.upgrades == []
         assert c.transport() == 'websocket'
         assert c.ws == ws
-        _, kwargs = c.http.ws_connect.await_args
+        _, kwargs = http.ws_connect.await_args
         assert 'ssl' in kwargs
         assert isinstance(kwargs['ssl'], ssl.SSLContext)
         assert kwargs['ssl'].verify_mode == ssl.CERT_NONE
@@ -718,10 +802,9 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_connection_with_cookies(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -732,18 +815,19 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
-        c.http._cookie_jar = [mock.MagicMock(), mock.MagicMock()]
-        c.http._cookie_jar[0].key = 'key'
-        c.http._cookie_jar[0].value = 'value'
-        c.http._cookie_jar[1].key = 'key2'
-        c.http._cookie_jar[1].value = 'value2'
+        http._cookie_jar = [mock.MagicMock(), mock.MagicMock()]
+        http._cookie_jar[0].key = 'key'
+        http._cookie_jar[0].value = 'value'
+        http._cookie_jar[1].key = 'key2'
+        http._cookie_jar[1].value = 'value2'
+        c = async_client.AsyncClient(http_session=lambda: http)
         c._read_loop_polling = mock.AsyncMock()
         c._read_loop_websocket = mock.AsyncMock()
         c._write_loop = mock.AsyncMock()
         on_connect = mock.MagicMock()
         c.on('connect', on_connect)
         await c.connect('ws://foo', transports=['websocket'])
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={},
             timeout=5,
@@ -753,10 +837,9 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_connection_with_cookie_header(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -767,7 +850,8 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
-        c.http._cookie_jar = []
+        http._cookie_jar = []
+        c = async_client.AsyncClient(http_session=lambda: http)
         c._read_loop_polling = mock.AsyncMock()
         c._read_loop_websocket = mock.AsyncMock()
         c._write_loop = mock.AsyncMock()
@@ -778,12 +862,12 @@ class TestAsyncClient:
             headers={'Cookie': 'key=value; key2=value2; key3="value3="'},
             transports=['websocket'],
         )
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={},
             timeout=5,
         )
-        c.http.cookie_jar.update_cookies.assert_called_once_with(
+        http.cookie_jar.update_cookies.assert_called_once_with(
             {'key': 'value', 'key2': 'value2', 'key3': 'value3='}
         )
 
@@ -791,10 +875,9 @@ class TestAsyncClient:
     @mock.patch('engineio.async_client.aiohttp.ClientWSTimeout',
                 new=mock_ws_timeout)
     async def test_websocket_connection_with_cookies_and_headers(self, _time):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -805,11 +888,12 @@ class TestAsyncClient:
                 'pingTimeout': 2000,
             },
         ).encode()
-        c.http._cookie_jar = [mock.MagicMock(), mock.MagicMock()]
-        c.http._cookie_jar[0].key = 'key'
-        c.http._cookie_jar[0].value = 'value'
-        c.http._cookie_jar[1].key = 'key2'
-        c.http._cookie_jar[1].value = 'value2'
+        http._cookie_jar = [mock.MagicMock(), mock.MagicMock()]
+        http._cookie_jar[0].key = 'key'
+        http._cookie_jar[0].value = 'value'
+        http._cookie_jar[1].key = 'key2'
+        http._cookie_jar[1].value = 'value2'
+        c = async_client.AsyncClient(http_session=lambda: http)
         c._read_loop_polling = mock.AsyncMock()
         c._read_loop_websocket = mock.AsyncMock()
         c._write_loop = mock.AsyncMock()
@@ -820,20 +904,19 @@ class TestAsyncClient:
             headers={'Foo': 'Bar', 'Cookie': 'key3=value3'},
             transports=['websocket'],
         )
-        c.http.ws_connect.assert_awaited_once_with(
+        http.ws_connect.assert_awaited_once_with(
             'ws://foo/engine.io/?transport=websocket&EIO=4&t=123.456',
             headers={'Foo': 'Bar'},
             timeout=5,
         )
-        c.http.cookie_jar.update_cookies.assert_called_once_with(
+        http.cookie_jar.update_cookies.assert_called_once_with(
             {'key3': 'value3'}
         )
 
     async def test_websocket_upgrade_no_pong(self):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.OPEN,
@@ -845,6 +928,7 @@ class TestAsyncClient:
             },
         ).encode()
         ws.send_str = mock.AsyncMock()
+        c = async_client.AsyncClient(http_session=lambda: http)
         c.sid = '123'
         c.current_transport = 'polling'
         c._read_loop_polling = mock.AsyncMock()
@@ -862,15 +946,15 @@ class TestAsyncClient:
         ws.send_str.assert_awaited_once_with('2probe')
 
     async def test_websocket_upgrade_successful(self):
-        c = async_client.AsyncClient()
-        c.http = mock.MagicMock(closed=False)
-        c.http.ws_connect = mock.AsyncMock()
-        ws = c.http.ws_connect.return_value
+        http = mock.MagicMock(closed=False)
+        http.ws_connect = mock.AsyncMock()
+        ws = http.ws_connect.return_value
         ws.receive = mock.AsyncMock()
         ws.receive.return_value.data = packet.Packet(
             packet.PONG, 'probe'
         ).encode()
         ws.send_str = mock.AsyncMock()
+        c = async_client.AsyncClient(http_session=lambda: http)
         c.sid = '123'
         c.base_url = 'http://foo'
         c.current_transport = 'polling'

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/async/test_server.py

@@ -716,6 +716,18 @@ class TestAsyncServer:
         assert len(s.sockets) == 0
         assert a._async['make_response'].call_args[0][0] == '400 BAD REQUEST'
 
+    @mock.patch('importlib.import_module')
+    async def test_post_request_after_upgrade(self, import_module):
+        a = self.get_async_mock(
+            {'REQUEST_METHOD': 'POST', 'QUERY_STRING': 'sid=foo'}
+        )
+        import_module.side_effect = [a]
+        s = async_server.AsyncServer()
+        s.sockets['foo'] = self._get_mock_socket()
+        s.sockets['foo'].upgraded = True
+        await s.handle_request('request')
+        assert a._async['make_response'].call_args[0][0] == '400 BAD REQUEST'
+
     @mock.patch('importlib.import_module')
     async def test_send(self, import_module):
         a = self.get_async_mock()

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/common/test_client.py

@@ -44,6 +44,17 @@ class TestClient:
         assert c.queue.__class__.__name__ == 'Queue'
         assert c.queue_empty.__name__ == 'Empty'
 
+    def test_external_session(self):
+        c = client.Client(http_session='foo')
+        assert c.http == 'foo'
+        assert c.external_http
+
+    def test_callable_session(self):
+        c = client.Client(http_session=lambda: 'foo')
+        assert c.http is None
+        assert c.http_factory() == 'foo'
+        assert c.external_http is False
+
     def test_custom_json(self):
         client.Client()
         assert packet.Packet.json == json
@@ -352,6 +363,22 @@ class TestClient:
         e.set()
         assert e.is_set()
 
+    @mock.patch('engineio.client.requests.Session')
+    def test_polling_connection_default_session(self, _session):
+        _session.return_value.request.return_value.status_code = 200
+        _session.return_value.request.return_value.content = payload.Payload(
+            packets=[
+                packet.Packet(
+                    packet.MESSAGE,  # incorrect on purpose
+                    {},
+                )
+            ]
+        ).encode().encode('utf-8')
+        c = client.Client()
+        with pytest.raises(exceptions.ConnectionError,
+                           match='OPEN packet not returned by server'):
+            c.connect('http://foo', headers={'Foo': 'Bar'})
+
     @mock.patch('engineio.client.time.time', return_value=123.456)
     @mock.patch('engineio.client.Client._send_request', return_value=None)
     def test_polling_connection_failed(self, _send_request, _time):
@@ -796,7 +823,7 @@ class TestClient:
         http.auth = None
         http.proxies = None
         http.cert = None
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -829,7 +856,7 @@ class TestClient:
         http.auth = None
         http.proxies = None
         http.cert = None
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -872,7 +899,7 @@ class TestClient:
         http.auth = None
         http.proxies = None
         http.cert = None
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -909,7 +936,7 @@ class TestClient:
         http.auth = ('foo', 'bar')
         http.proxies = None
         http.cert = None
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -941,7 +968,7 @@ class TestClient:
         http.auth = None
         http.proxies = None
         http.cert = 'foo.crt'
-        c = client.Client(http_session=http, ssl_verify=False)
+        c = client.Client(http_session=lambda: http, ssl_verify=False)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -974,7 +1001,7 @@ class TestClient:
         http.auth = None
         http.proxies = None
         http.cert = ('foo.crt', 'key.pem')
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -1010,7 +1037,7 @@ class TestClient:
         http.proxies = None
         http.cert = ('foo.crt', 'key.pem')
         http.verify = 'ca-bundle.crt'
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -1076,7 +1103,7 @@ class TestClient:
             http.auth = None
             http.proxies = proxies
             http.cert = None
-            c = client.Client(http_session=http)
+            c = client.Client(http_session=lambda: http)
             c._read_loop_polling = mock.MagicMock()
             c._read_loop_websocket = mock.MagicMock()
             c._write_loop = mock.MagicMock()
@@ -1115,7 +1142,7 @@ class TestClient:
         http.proxies = None
         http.cert = None
         http.verify = False
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()
@@ -1149,7 +1176,7 @@ class TestClient:
         http.proxies = None
         http.cert = None
         http.verify = 'ca-bundle.crt'
-        c = client.Client(http_session=http)
+        c = client.Client(http_session=lambda: http)
         c._read_loop_polling = mock.MagicMock()
         c._read_loop_websocket = mock.MagicMock()
         c._write_loop = mock.MagicMock()

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/common/test_middleware.py

@@ -85,6 +85,8 @@ class TestWSGIApp:
                    'Not Found')
         check_path('/bar/foo', '404 Not Found', 'text/plain', 'Not Found')
         check_path('', '404 Not Found', 'text/plain', 'Not Found')
+        check_path('/static/../../LICENSE', '404 Not Found', 'text/plain',
+                   'Not Found')
 
         m.static_files[''] = 'index.html'
         check_path('/static/test/', '200 OK', 'text/html', '<html></html>\n')

{python_engineio-4.14.0 → python_engineio-4.15.0}/tests/common/test_server.py

@@ -859,6 +859,17 @@ class TestServer:
         s.handle_request(environ, start_response)
         assert start_response.call_args[0][0] == '400 BAD REQUEST'
 
+    def test_post_request_after_upgrade(self):
+        s = server.Server()
+        mock_socket = self._get_mock_socket()
+        mock_socket.upgraded = True
+        mock_socket.handle_post_request = mock.MagicMock()
+        s.sockets['foo'] = mock_socket
+        environ = {'REQUEST_METHOD': 'POST', 'QUERY_STRING': 'EIO=4&sid=foo'}
+        start_response = mock.MagicMock()
+        s.handle_request(environ, start_response)
+        assert start_response.call_args[0][0] == '400 BAD REQUEST'
+
     def test_send(self):
         s = server.Server()
         mock_socket = self._get_mock_socket()

{python_engineio-4.14.0 → python_engineio-4.15.0}/tox.ini

@@ -17,6 +17,12 @@ deps=
 commands=
     flake8 --exclude=".*" --ignore=W503,E402,E722 src/engineio tests examples
 
+[testenv:zizmor]
+deps=
+    zizmor
+commands=
+    zizmor --offline .forgejo/workflows/tests.yml
+
 [testenv:docs]
 changedir=docs
 deps=
@@ -26,3 +32,16 @@ allowlist_externals=
     make
 commands=
     make html
+
+[testenv:lint]
+deps=
+    flake8   
+    zizmor
+    sphinx
+    furo
+allowlist_externals=
+    make
+commands=
+    flake8 --exclude=".*" --ignore=W503,E402,E722 src/engineio tests examples
+    zizmor --offline .forgejo/workflows/tests.yml
+    make -C docs html