Lifts aiohttp upper version cap by refactoring a subset of tests to use mocks.

Author: krisctl

setup.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 The MathWorks, Inc.
+# Copyright 2020-2025 The MathWorks, Inc.
 import os
 from pathlib import Path
 from shutil import which
@@ -60,17 +60,17 @@ def run(self):
     "pytest-timeout",
     "psutil",
     "urllib3",
-    "requests",
     "pytest-playwright",
 ]
 
 INSTALL_REQUIRES = [
-    "aiohttp>=3.7.4, <=3.10.5",
+    "aiohttp>=3.7.4",
     "aiohttp_session[secure]",
     "importlib-metadata",
     "importlib-resources",
     "psutil",
     "watchdog",
+    "requests",
 ]
 
 HERE = Path(__file__).parent.resolve()

tests/integration/integration_tests_with_license/test_http_end_points.py

@@ -1,4 +1,4 @@
-# Copyright 2023-2024 The MathWorks, Inc.
+# Copyright 2023-2025 The MathWorks, Inc.
 
 """
 Contains integration tests which exercise HTTP endpoints of interest exposed by matlab-proxy-app
@@ -246,24 +246,23 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
 # Fixtures
 @pytest.fixture
 def matlab_proxy_app_fixture(
-    loop,
+    event_loop,
 ):
     """A pytest fixture which yields a real matlab server to be used by tests.
 
     Args:
-        loop (Event event_loop): The built-in event event_loop provided by pytest.
+        event_loop (Event loop): The built-in event loop provided by pytest.
 
     Yields:
         real_matlab_server : A real matlab web server used by tests.
     """
 
     try:
-        with RealMATLABServer(loop) as matlab_proxy_app:
+        with RealMATLABServer(event_loop) as matlab_proxy_app:
             yield matlab_proxy_app
     except ProcessLookupError as e:
         _logger.debug("ProcessLookupError found in matlab proxy app fixture")
         _logger.debug(e)
-        pass
 
 
 @pytest.fixture

tests/unit/fixtures/fixture_auth.py

@@ -0,0 +1,19 @@
+# Copyright 2025 The MathWorks, Inc.
+"""A common fixture that could be used by various test classes to disable authentication"""
+
+import pytest
+
+
+@pytest.fixture
+def patch_authenticate_access_decorator(mocker):
+    """
+    Fixture to patch the authenticate_access decorator for testing purposes.
+
+    This fixture mocks the 'authenticate_request' function from the
+    'token_auth' module to always return True,
+    effectively bypassing authentication for tests.
+    """
+    return mocker.patch(
+        "matlab_proxy.util.mwi.token_auth.authenticate_request",
+        return_value=True,
+    )

tests/unit/mocks/mock_client.py

@@ -0,0 +1,42 @@
+# Copyright 2025 The MathWorks, Inc.
+
+
+class MockWebSocketClient:
+    """Mock class for testing WebSocket client functionality.
+
+    This class simulates a WebSocket client for testing purposes, providing async iteration
+    over predefined messages and basic client functionality.
+
+    Args:
+        text (str, optional): Text to be returned by text() method. Defaults to None.
+        status (int, optional): HTTP status code. Defaults to 200.
+        headers (dict, optional): HTTP headers. Defaults to None.
+        messages (list, optional): List of messages to be returned during iteration. Defaults to None.
+    """
+
+    def __init__(
+        self, text=None, status: int = 200, headers=None, messages=None
+    ) -> None:
+        self._text = text
+        self.status = status
+        self.headers = headers
+        self.messages = messages or []
+        self._message_iter = iter(self.messages)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            return next(self._message_iter)
+        except StopIteration as exc:
+            raise StopAsyncIteration from exc
+
+    async def text(self):
+        return self._text
+
+    async def __aexit__(self, *args) -> None:
+        pass
+
+    async def __aenter__(self):
+        return self

tests/unit/test_app.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 The MathWorks, Inc.
+# Copyright 2020-2025 The MathWorks, Inc.
 
 import asyncio
 import datetime
@@ -9,13 +9,18 @@
 from datetime import timedelta, timezone
 from http import HTTPStatus
 
-import aiohttp
 import pytest
-import tests.unit.test_constants as test_constants
+from aiohttp import WSMsgType
+from aiohttp.web import WebSocketResponse
+from multidict import CIMultiDict
 
+import tests.unit.test_constants as test_constants
 from matlab_proxy import app, util
+from matlab_proxy.app import matlab_view
 from matlab_proxy.util.mwi import environment_variables as mwi_env
 from matlab_proxy.util.mwi.exceptions import EntitlementError, MatlabInstallError
+from tests.unit.fixtures.fixture_auth import patch_authenticate_access_decorator
+from tests.unit.mocks.mock_client import MockWebSocketClient
 
 
 @pytest.mark.parametrize(
@@ -61,7 +66,7 @@ def test_configure_no_proxy_in_env(monkeypatch, no_proxy_user_configuration):
     )
 
 
-def test_create_app(loop):
+def test_create_app(event_loop):
     """Test if aiohttp server is being created successfully.
 
     Checks if the aiohttp server is created successfully, routes, startup and cleanup
@@ -75,7 +80,7 @@ def test_create_app(loop):
     # Verify app server has a cleanup task
     # By default there is 1 for clean up task
     assert len(test_server.on_cleanup) > 1
-    loop.run_until_complete(test_server["state"].stop_server_tasks())
+    event_loop.run_until_complete(test_server["state"].stop_server_tasks())
 
 
 def get_email():
@@ -245,9 +250,33 @@ def __exit__(self, exc_type, exc_value, exc_traceback):
         self.loop.run_until_complete(self.server.cleanup())
 
 
+@pytest.fixture
+def mock_request(mocker):
+    """Creates a mock request with required attributes"""
+    req = mocker.MagicMock()
+    req.app = {
+        "state": mocker.MagicMock(matlab_port=8000),
+        "settings": {"matlab_protocol": "http", "mwapikey": "test-key"},
+    }
+    req.headers = CIMultiDict()
+    req.cookies = {}
+    return req
+
+
+@pytest.fixture(name="mock_websocket_messages")
+def mock_messages(mocker):
+    # Mock WebSocket messages
+    return [
+        mocker.MagicMock(type=WSMsgType.TEXT, data="test message"),
+        mocker.MagicMock(type=WSMsgType.BINARY, data=b"test binary"),
+        mocker.MagicMock(type=WSMsgType.PING),
+        mocker.MagicMock(type=WSMsgType.PONG),
+    ]
+
+
 @pytest.fixture(name="test_server")
 def test_server_fixture(
-    loop,
+    event_loop,
     aiohttp_client,
     monkeypatch,
 ):
@@ -263,7 +292,7 @@ def test_server_fixture(
     # Disabling the authentication token mechanism explicitly
     monkeypatch.setenv(mwi_env.get_env_name_enable_mwi_auth_token(), "False")
     try:
-        with FakeServer(loop, aiohttp_client) as test_server:
+        with FakeServer(event_loop, aiohttp_client) as test_server:
             yield test_server
     except ProcessLookupError:
         pass
@@ -350,7 +379,7 @@ async def test_start_matlab_route(test_server):
     await __check_for_matlab_status(test_server, "starting")
 
 
-async def __check_for_matlab_status(test_server, status):
+async def __check_for_matlab_status(test_server, status, sleep_interval=0.5):
     """Helper function to check if the status of MATLAB returned by the server is either of the values mentioned in statuses
 
     Args:
@@ -369,7 +398,7 @@ async def __check_for_matlab_status(test_server, status):
             break
         else:
             count += 1
-            await asyncio.sleep(0.5)
+            await asyncio.sleep(sleep_interval)
             if count > test_constants.FIVE_MAX_TRIES:
                 raise ConnectionError
 
@@ -592,19 +621,6 @@ async def test_matlab_proxy_http_post_request(proxy_payload, test_server):
             raise ConnectionError
 
 
-# While acceessing matlab-proxy directly, the web socket request looks like
-#     {
-#         "connection": "Upgrade",
-#         "Upgrade": "websocket",
-#     }
-# whereas while accessing matlab-proxy with nginx as the reverse proxy, the nginx server
-# modifies the web socket request to
-#     {
-#         "connection": "upgrade",
-#         "upgrade": "websocket",
-#     }
-
-
 async def test_set_licensing_info_put_nlm(test_server):
     """Test to check endpoint : "/set_licensing_info"
 
@@ -641,35 +657,70 @@ async def test_set_licensing_info_put_invalid_license(test_server):
     assert resp.status == HTTPStatus.BAD_REQUEST
 
 
+# While acceessing matlab-proxy directly, the web socket request looks like
+#     {
+#         "connection": "Upgrade",
+#         "Upgrade": "websocket",
+#     }
+# whereas while accessing matlab-proxy with nginx as the reverse proxy, the nginx server
+# modifies the web socket request to
+#     {
+#         "connection": "upgrade",
+#         "upgrade": "websocket",
+#     }
 @pytest.mark.parametrize(
     "headers",
     [
-        {
-            "connection": "Upgrade",
-            "Upgrade": "websocket",
-        },
-        {
-            "connection": "upgrade",
-            "upgrade": "websocket",
-        },
+        CIMultiDict(
+            {
+                "connection": "Upgrade",
+                "Upgrade": "websocket",
+            }
+        ),
+        CIMultiDict(
+            {
+                "connection": "upgrade",
+                "upgrade": "websocket",
+            }
+        ),
     ],
     ids=["Uppercase header", "Lowercase header"],
 )
-async def test_matlab_proxy_web_socket(test_server, headers):
-    """Test to check if test_server proxies web socket request to fake matlab server
+async def test_matlab_view_websocket_success(
+    mocker,
+    mock_request,
+    mock_websocket_messages,
+    headers,
+    patch_authenticate_access_decorator,
+):
+    """Test successful websocket connection and message forwarding"""
 
-    Args:
-        test_server (aiohttp_client): Test Server to send HTTP Requests.
-    """
+    # Configure request for WebSocket
+    mock_request.headers = headers
+    mock_request.method = "GET"
+    mock_request.path_qs = "/test"
 
-    await wait_for_matlab_to_be_up(test_server, test_constants.ONE_SECOND_DELAY)
-    resp = await test_server.ws_connect("/http_ws_request.html/", headers=headers)
-    text = await resp.receive()
-    websocket_response_string = (
-        "Hello world"  # This string is set by the web_socket_handler in devel.py
+    # Mock WebSocket setup
+    mock_ws_server = mocker.MagicMock(spec=WebSocketResponse)
+    mocker.patch(
+        "matlab_proxy.app.aiohttp.web.WebSocketResponse", return_value=mock_ws_server
+    )
+
+    # Mock WebSocket client
+    mock_ws_client = MockWebSocketClient(messages=mock_websocket_messages)
+    mocker.patch(
+        "matlab_proxy.app.aiohttp.ClientSession.ws_connect", return_value=mock_ws_client
     )
-    assert text.type == aiohttp.WSMsgType.TEXT
-    assert text.data == websocket_response_string
+
+    # Execute
+    result = await matlab_view(mock_request)
+
+    # Assertions
+    assert result == mock_ws_server
+    assert mock_ws_server.send_str.call_count == 1
+    assert mock_ws_server.send_bytes.call_count == 1
+    assert mock_ws_server.ping.call_count == 1
+    assert mock_ws_server.pong.call_count == 1
 
 
 async def test_set_licensing_info_put_mhlm(test_server):
@@ -992,7 +1043,7 @@ async def test_set_licensing_mhlm_single_entitlement(
     assert resp_json["licensing"]["entitlementId"] == "Entitlement3"
 
     # validate that MATLAB has started correctly
-    await __check_for_matlab_status(test_server, "up")
+    await __check_for_matlab_status(test_server, "up", sleep_interval=2)
 
     # test-cleanup: unset licensing
     # without this, we can leave test drool related to cached license file