Removes upperbound limitation on pytest-asyncio dependency version.

Author: Kumar Pallav

pyproject.toml

@@ -62,7 +62,7 @@ test = [
     "psutil",
     "urllib3",
     "pytest-playwright",
-    "pytest-asyncio==0.24.0",
+    "pytest-asyncio",
 ]
 dev = [
     "aiohttp-devtools",

tests/integration/integration_tests_with_license/test_http_end_points.py

@@ -170,10 +170,19 @@ class RealMATLABServer:
     Setting up the server in the context of Pytest.
     """
 
-    def __init__(self, event_loop):
-        self.event_loop = event_loop
-
-    def __enter__(self):
+    def __init__(self):
+        self.proc = None
+        self.dpipe = None
+        self.mwi_app_port = None
+        self.matlab_config_file_path = None
+        self.temp_dir_path = None
+        self.temp_dir_name = None
+        self.mwi_base_url = None
+        self.headers = None
+        self.connection_scheme = None
+        self.url = None
+
+    async def __aenter__(self):
         # Store the matlab proxy logs in os.pipe for testing
         # os.pipe2 is only supported in Linux systems
         _logger.info("Setting up MATLAB Server for integration test")
@@ -196,8 +205,8 @@ def __enter__(self):
             "MWI_BASE_URL": self.mwi_base_url,
         }
 
-        self.proc = self.event_loop.run_until_complete(
-            utils.start_matlab_proxy_app(out=self.dpipe[1], input_env=input_env)
+        self.proc = await utils.start_matlab_proxy_app(
+            out=self.dpipe[1], input_env=input_env
         )
 
         utils.wait_server_info_ready(self.mwi_app_port)
@@ -237,28 +246,23 @@ async def _terminate_process(self, timeout=0):
             await process.wait()
             _logger.debug("Killed the MATLAB process after timeout.")
 
-    def __exit__(self, exc_type, exc_value, exc_traceback):
+    async def __aexit__(self, exc_type, exc_value, exc_traceback):
         _logger.info("Tearing down the MATLAB Server.")
-        self.event_loop.run_until_complete(self._terminate_process(timeout=10))
+        await self._terminate_process(timeout=10)
         _logger.debug("Terminated the MATLAB process.")
 
 
 # Fixtures
 @pytest.fixture
-def matlab_proxy_app_fixture(
-    event_loop,
-):
+async def matlab_proxy_app_fixture():
     """A pytest fixture which yields a real matlab server to be used by tests.
 
-    Args:
-        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(event_loop) as matlab_proxy_app:
+        async with RealMATLABServer() as matlab_proxy_app:
             yield matlab_proxy_app
     except ProcessLookupError as e:
         _logger.debug("ProcessLookupError found in matlab proxy app fixture")

tests/unit/test_app.py

@@ -68,7 +68,7 @@ def test_configure_no_proxy_in_env(monkeypatch, no_proxy_user_configuration):
     )
 
 
-def test_create_app(event_loop):
+async def test_create_app():
     """Test if aiohttp server is being created successfully.
 
     Checks if the aiohttp server is created successfully, routes, startup and cleanup
@@ -83,7 +83,7 @@ def test_create_app(event_loop):
     # By default there is 1 for clean up task
     assert len(test_server.on_shutdown) == 1
     assert len(test_server.on_cleanup) == 1
-    event_loop.run_until_complete(test_server["state"].stop_server_tasks())
+    await test_server["state"].stop_server_tasks()
 
 
 def get_email():
@@ -231,6 +231,60 @@ def test_marshal_error(actual_error, expected_error):
     assert app.marshal_error(actual_error) == expected_error
 
 
+async def async_configure_and_start(app_instance):
+    """Async version of app.configure_and_start
+    This async version is necessary for pytest testing because:
+    1. In the test environment, we're already running inside an event loop managed by pytest-aiohttp
+    2. The app.py configure_and_start uses loop.run_until_complete() which would block the test event loop
+    3. Using 'await' instead allows the test event loop to continue processing other tasks
+    """
+    # Get web logger
+    web_logger = None if not mwi_env.is_web_logging_enabled() else app.logger
+
+    # Setup the session storage,
+    # Uniqified per session to prevent multiple proxy servers on the same FQDN from interfering with each other.
+    uniqify_session_cookie = app.secrets.token_hex()
+    fernet_key = app.fernet.Fernet.generate_key()
+    f = app.fernet.Fernet(fernet_key)
+    app.aiohttp_session_setup(
+        app_instance,
+        app.EncryptedCookieStorage(
+            f, cookie_name="matlab-proxy-session-" + uniqify_session_cookie
+        ),
+    )
+
+    # Setup runner
+    runner = app.web.AppRunner(app_instance, access_log=web_logger)
+
+    await runner.setup()
+
+    # Prepare site to start, then set port of the app.
+    site = app.util.prepare_site(app_instance, runner)
+
+    # This would be required when MWI_APP_PORT env variable is not set and the site starts on a random port.
+    app_instance["settings"]["app_port"] = site._port
+
+    # Update the site origin in settings.
+    # The origin will be used for communicating with the Embedded connector.
+    app_instance["settings"]["mwi_server_url"] = app.util.get_access_url(app_instance)
+    await site.start()
+
+    app.logger.debug("Starting MATLAB proxy app")
+    app.logger.debug(
+        f" with base_url: {app_instance['settings']['base_url']} and app_port:{app_instance['settings']['app_port']}."
+    )
+
+    app_instance["state"].create_server_info_file()
+
+    # Startup tasks are being done here as app.on_startup leads
+    # to a race condition for mwi_server_url information which is
+    # extracted from the site info.
+    # Use await instead of run_until_complete
+    await app.start_background_tasks(app_instance)
+
+    return app_instance
+
+
 class FakeServer:
     """Context Manager class which returns a web server wrapped in aiohttp_client pytest fixture
     for testing.
@@ -239,18 +293,20 @@ class FakeServer:
     Setting up the server in the context of Pytest.
     """
 
-    def __init__(self, event_loop, aiohttp_client):
-        self.loop = event_loop
-        self.aiohttp_client = aiohttp_client
+    def __init__(self, aiohttp_client):
+        self.aiohttp_client = aiohttp_client  # This is the pytest fixture (factory function) that is passed to the constructor
+        self.server = None  # This will hold the created server instance
+        self.client = None  # This will hold the actual client instance created by calling the factory function with our server
 
-    def __enter__(self):
-        server = app.create_app()
-        self.server = app.configure_and_start(server)
-        return self.loop.run_until_complete(self.aiohttp_client(self.server))
+    async def __aenter__(self):
+        self.server = app.create_app()
+        self.server = await async_configure_and_start(self.server)
+        self.client = await self.aiohttp_client(self.server)
+        return self.client
 
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        self.loop.run_until_complete(self.server.shutdown())
-        self.loop.run_until_complete(self.server.cleanup())
+    async def __aexit__(self, exc_type, exc_value, exc_traceback):
+        await self.server.shutdown()
+        await self.server.cleanup()
 
 
 @pytest.fixture
@@ -281,12 +337,11 @@ def mock_messages(mocker):
     ]
 
 
-@pytest.fixture(name="test_server")
-def test_server_fixture(event_loop, aiohttp_client, monkeypatch, request):
+@pytest.fixture
+async def test_server(aiohttp_client, monkeypatch, request):
     """A pytest fixture which yields a test server to be used by tests.
 
     Args:
-        loop (Event loop): The built-in event loop provided by pytest.
         aiohttp_client (aiohttp_client): Built-in pytest fixture used as a wrapper to the aiohttp web server.
 
     Yields:
@@ -305,7 +360,7 @@ def test_server_fixture(event_loop, aiohttp_client, monkeypatch, request):
         monkeypatch.setenv(env_var_name, env_var_value)
 
     try:
-        with FakeServer(event_loop, aiohttp_client) as test_server:
+        async with FakeServer(aiohttp_client) as test_server:
             yield test_server
 
     except ProcessLookupError:

tests/unit/test_app_state.py

@@ -56,12 +56,11 @@ def sample_settings_fixture(tmp_path):
 
 
 @pytest.fixture
-def app_state_fixture(sample_settings_fixture, event_loop):
+async def app_state_fixture(sample_settings_fixture):
     """A pytest fixture which returns an instance of AppState class with no errors.
 
     Args:
         sample_settings_fixture (dict): A dictionary of sample settings to be used by
-        event_loop : A pytest builtin fixture
 
     Returns:
         AppState: An object of the AppState class
@@ -72,7 +71,7 @@ def app_state_fixture(sample_settings_fixture, event_loop):
 
     yield app_state
 
-    event_loop.run_until_complete(app_state.stop_server_tasks())
+    await app_state.stop_server_tasks()
 
 
 @pytest.fixture
@@ -109,13 +108,12 @@ def app_state_with_token_auth_fixture(
 
 
 @pytest.fixture
-def mocker_os_patching_fixture(mocker, platform, event_loop):
+async def mocker_os_patching_fixture(mocker, platform):
     """A pytest fixture which patches the is_* functions in system.py module
 
     Args:
         mocker : Built in pytest fixture
         platform (str): A string representing "windows", "linux" or "mac"
-        event_loop : A pytest builtin fixture
 
     Returns:
         mocker: Built in pytest fixture with patched calls to system.py module.
@@ -124,7 +122,6 @@ def mocker_os_patching_fixture(mocker, platform, event_loop):
     mocker.patch("matlab_proxy.app_state.system.is_windows", return_value=False)
     mocker.patch("matlab_proxy.app_state.system.is_mac", return_value=False)
     mocker.patch("matlab_proxy.app_state.system.is_posix", return_value=False)
-    mocker.patch("matlab_proxy.app_state.util.get_event_loop", return_value=event_loop)
 
     if platform == "linux":
         mocker.patch("matlab_proxy.app_state.system.is_linux", return_value=True)

tests/unit/test_non_dev_mode.py

@@ -124,9 +124,8 @@ def mock_settings_get_fixture(mocker):
     )
 
 
-@pytest.fixture(name="test_server")
-def test_server_fixture(
-    event_loop,
+@pytest.fixture
+async def test_server(
     aiohttp_client,
     build_frontend,
     matlab_port_setup,
@@ -140,7 +139,6 @@ def test_server_fixture(
     This fixture 'initializes' the test server with different constraints from the test server in test_app.py
 
     Args:
-        event_loop : Event loop
         aiohttp_client : A built-in pytest fixture
         build_frontend: Pytest fixture which generates the directory structure of static files with some placeholder content
         matlab_port_setup: Pytest fixture which monkeypatches 'MWI_DEV' env to False. This is required for the test_server to add static content
@@ -150,7 +148,7 @@ def test_server_fixture(
         [aiohttp_client]: A aiohttp_client to send HTTP requests.
     """
 
-    with FakeServer(event_loop, aiohttp_client) as test_server:
+    async with FakeServer(aiohttp_client) as test_server:
         yield test_server
 
 

tests/unit/util/mwi/test_token_auth.py

@@ -89,8 +89,8 @@ async def fake_endpoint(request):
 
 
 @pytest.fixture
-def fake_server_with_auth_enabled(
-    event_loop, aiohttp_client, monkeypatch, get_custom_auth_token_str
+async def fake_server_with_auth_enabled(
+    aiohttp_client, monkeypatch, get_custom_auth_token_str
 ):
     auth_token = get_custom_auth_token_str
     auth_enablement = "True"
@@ -120,7 +120,7 @@ def fake_server_with_auth_enabled(
     aiohttp_session_setup(
         app, EncryptedCookieStorage(f, cookie_name="matlab-proxy-session")
     )
-    return event_loop.run_until_complete(aiohttp_client(app))
+    return await aiohttp_client(app)
 
 
 async def test_set_value_with_token(
@@ -256,7 +256,7 @@ async def test_get_value_with_token_in_query_params(
 
 
 @pytest.fixture
-def fake_server_without_auth_enabled(event_loop, aiohttp_client, monkeypatch):
+async def fake_server_without_auth_enabled(aiohttp_client, monkeypatch):
     auth_enablement = "False"
     monkeypatch.setenv(
         mwi_env.get_env_name_enable_mwi_auth_token(), str(auth_enablement)
@@ -281,7 +281,7 @@ def fake_server_without_auth_enabled(event_loop, aiohttp_client, monkeypatch):
     aiohttp_session_setup(
         app, EncryptedCookieStorage(f, cookie_name="matlab-proxy-session")
     )
-    return event_loop.run_until_complete(aiohttp_client(app))
+    return await aiohttp_client(app)
 
 
 async def test_get_value(fake_server_without_auth_enabled):

tests/unit/util/test_mw.py

@@ -519,7 +519,7 @@ def test_range_matlab_connector_ports():
     not system.is_linux(),
     reason="Xvfb is only required on linux based operating systems",
 )
-async def test_create_xvfb_process(event_loop):
+async def test_create_xvfb_process():
     """Test to check if more than 1 xvfb process can be created with -displayfd flag
 
     Creates 2 xvfb processes with '-displayfd' flag and  checks if the processes are

tests/unit/util/test_util.py

@@ -19,26 +19,27 @@ def test_get_supported_termination_signals():
     assert len(system.get_supported_termination_signals()) >= 1
 
 
-def test_add_signal_handlers(event_loop: asyncio.AbstractEventLoop):
-    """Test to check if signal handlers are being added to asyncio event_loop
-
-    Args:
-        event_loop (asyncio event loop): built-in pytest fixture.
-    """
-
-    event_loop = add_signal_handlers(event_loop)
-
-    # In posix systems, event loop is modified with new signal handlers
-    if system.is_posix():
-        assert event_loop._signal_handlers is not None
-        assert event_loop._signal_handlers.items() is not None
-
-    else:
-        import signal
-
-        # In a windows system, the signal handlers are added to the 'signal' package.
-        for interrupt_signal in system.get_supported_termination_signals():
-            assert signal.getsignal(interrupt_signal) is not None
+def test_add_signal_handlers():
+    """Test to check if signal handlers are being added to asyncio event_loop"""
+
+    test_loop = asyncio.new_event_loop()
+    test_loop = add_signal_handlers(test_loop)
+    try:
+        # In posix systems, event loop is modified with new signal handlers
+        if system.is_posix():
+            assert test_loop._signal_handlers is not None
+            # Check that the signal handlers dictionary is not empty
+            assert len(test_loop._signal_handlers) > 0
+
+        else:
+            import signal
+
+            # In a windows system, the signal handlers are added to the 'signal' package.
+            for interrupt_signal in system.get_supported_termination_signals():
+                assert signal.getsignal(interrupt_signal) is not None
+
+    finally:
+        test_loop.close()
 
 
 def test_get_child_processes_no_children_initially(mocker):