matlab-proxy 0.25.1__py3-none-any.whl → 0.27.0__py3-none-any.whl

matlab_proxy_manager/web/app.py

@@ -1,4 +1,4 @@
-# Copyright 2024 The MathWorks, Inc.
+# Copyright 2024-2025 The MathWorks, Inc.
 
 import asyncio
 import os
@@ -14,6 +14,7 @@ from aiohttp import ClientSession, client_exceptions, web
 import matlab_proxy.util.mwi.environment_variables as mwi_env
 import matlab_proxy.util.system as mwi_sys
 import matlab_proxy_manager.lib.api as mpm_lib
+import matlab_proxy.constants as mp_constants
 from matlab_proxy_manager.utils import constants, helpers, logger
 from matlab_proxy_manager.utils import environment_variables as mpm_env
 from matlab_proxy_manager.utils.auth import authenticate_access_decorator
@@ -44,6 +45,9 @@ def init_app() -> web.Application:
     # Async event is utilized to signal app termination from this and other modules
     app["shutdown_event"] = asyncio.Event()
 
+    # Tracks whether default matlab proxy is started or not
+    app["has_default_matlab_proxy_started"] = False
+
     # Create and get the proxy manager data directory
     try:
         data_dir = helpers.create_and_get_proxy_manager_data_dir()
@@ -54,6 +58,10 @@ def init_app() -> web.Application:
     # Setup idle timeout monitor for the app
     monitor = OrphanedProcessMonitor(app)
 
+    # Load existing matlab proxy servers into app state for consistency
+    app["servers"] = helpers.pre_load_from_state_file(app.get("data_dir"))
+    log.debug("Loaded existing matlab proxy servers into app state: %s", app["servers"])
+
     async def start_idle_monitor(app):
         """Start the idle timeout monitor."""
         app["monitor_task"] = asyncio.create_task(monitor.start())
@@ -102,7 +110,7 @@ def init_app() -> web.Application:
     return app
 
 
-async def start_app(env_vars: namedtuple):
+async def start_app(env_vars):
     """
     Initialize and start the web application.
 
@@ -118,9 +126,7 @@ async def start_app(env_vars: namedtuple):
     app["port"] = env_vars.mpm_port
     app["auth_token"] = env_vars.mpm_auth_token
     app["parent_pid"] = env_vars.mpm_parent_pid
-
-    # Start default matlab proxy
-    await _start_default_proxy(app)
+    app["base_url_prefix"] = env_vars.base_url_prefix
 
     web_logger = None if not mwi_env.is_web_logging_enabled() else log
 
@@ -175,6 +181,8 @@ def _register_signal_handler(loop, app):
 def _catch_signals(app):
     """Handle termination signals for graceful shutdown."""
     # Poll for parent process to clean up to avoid race conditions in cleanup of matlab proxies
+    # Ideally, we should minimize the work done when we catch exit signals, which would mean the
+    # polling for parent process should happen elsewhere
     helpers.poll_for_server_deletion()
     app.get("shutdown_event").set()
 
@@ -190,13 +198,13 @@ async def _start_default_proxy(app):
         parent_id=app.get("parent_pid"),
         is_shared_matlab=True,
         mpm_auth_token=app.get("auth_token"),
+        base_url_prefix=app.get("base_url_prefix"),
     )
-    if not server_process:
-        log.error("Failed to start default matlab proxy using Jupyter")
-        return
+    errors = server_process.get("errors")
 
-    # Load existing matlab proxy servers into app state for consistency
-    app["servers"] = helpers.pre_load_from_state_file(app.get("data_dir"))
+    # Raising an exception if there was an error starting the default MATLAB proxy
+    if errors:
+        raise Exception(":".join(errors))
 
     # Add the new/existing server to the app state
     app["servers"][server_process.get("id")] = server_process
@@ -259,12 +267,21 @@ async def proxy(req):
             f"Required header: ${constants.HEADER_MWI_MPM_CONTEXT} not found in the request"
         )
 
+    # Raising exception from here is not cleanly handled by Jupyter server proxy.
+    # It only shows 599 with a generic stream closed error message.
+    # Hence returning 503 with custom error message as response.
+    try:
+        await _start_default_proxy_if_not_already_started(req)
+    except Exception as e:
+        log.error("Error starting default proxy: %s", e)
+        return _render_error_page(f"Error during startup: {e}")
+
     client_key = f"{ctx}_{ident}"
     default_key = f"{ctx}_default"
     group_two_rel_url = match.group(2)
 
     backend_server = _get_backend_server(req, client_key, default_key)
-    proxy_url = f'{backend_server.get("absolute_url")}/{group_two_rel_url}'
+    proxy_url = f"{backend_server.get('absolute_url')}/{group_two_rel_url}"
     log.debug("Proxy URL: %s", proxy_url)
 
     if (
@@ -326,7 +343,9 @@ async def _forward_websocket_request(
     Returns:
         web.WebSocketResponse: The response from the backend server
     """
-    ws_server = web.WebSocketResponse()
+    ws_server = web.WebSocketResponse(
+        max_msg_size=mp_constants.MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB, compress=True
+    )
     await ws_server.prepare(req)
 
     async with aiohttp.ClientSession(
@@ -335,7 +354,11 @@ async def _forward_websocket_request(
         connector=aiohttp.TCPConnector(ssl=False),
     ) as client_session:
         try:
-            async with client_session.ws_connect(proxy_url) as ws_client:
+            async with client_session.ws_connect(
+                proxy_url,
+                max_msg_size=mp_constants.MAX_WEBSOCKET_MESSAGE_SIZE_IN_MB,  # max websocket message size from MATLAB to browser
+                compress=12,  # enable websocket messages compression
+            ) as ws_client:
 
                 async def ws_forward(ws_src, ws_dest):
                     async for msg in ws_src:
@@ -373,6 +396,13 @@ async def _forward_websocket_request(
                             await ws_dest.close(
                                 code=ws_dest.close_code, message=msg.extra
                             )
+                        elif msg_type == aiohttp.WSMsgType.ERROR:
+                            log.error(f"WebSocket error received: {msg}")
+                            if "exceeds limit" in str(msg.data):
+                                log.error(
+                                    f"Message too large: {msg.data}. Please refresh browser tab to reconnect."
+                                )
+                            break
                         else:
                             raise ValueError(f"Unexpected message type: {msg}")
 
@@ -421,6 +451,20 @@ async def _forward_http_request(
         return web.Response(headers=headers, status=res.status, body=body)
 
 
+async def _start_default_proxy_if_not_already_started(req):
+    app = req.app
+    req_path = req.rel_url
+
+    # Start default matlab-proxy only when it is not already started and
+    # if the request path contains the default MATLAB path (/matlab/default)
+    if not app.get(
+        "has_default_matlab_proxy_started", False
+    ) and constants.MWI_DEFAULT_MATLAB_PATH in str(req_path):
+        log.debug("Starting default matlab-proxy for request path: %s", str(req_path))
+        await _start_default_proxy(app)
+        app["has_default_matlab_proxy_started"] = True
+
+
 def _get_backend_server(req: web.Request, client_key: str, default_key: str) -> dict:
     """
     Retrieves the backend server configuration for a given client key.
@@ -444,18 +488,22 @@ def _redirect_to_default(req_path) -> None:
     Raises:
         web.HTTPFound: Redirects the client to the new URL.
     """
-    new_redirect_url = f'{str(req_path).rstrip("/")}/default/'
+    new_redirect_url = f"{str(req_path).rstrip('/')}/default/"
     log.info("Redirecting to %s", new_redirect_url)
     raise web.HTTPFound(new_redirect_url)
 
 
 def _render_error_page(error_msg: str) -> web.Response:
     """Returns 503 with error text"""
-    return web.HTTPServiceUnavailable(text=f"Error: {error_msg}")
+    return web.HTTPServiceUnavailable(
+        text=f'<p style="color: red;">{error_msg}</p>', content_type="text/html"
+    )
 
 
-def _fetch_and_validate_required_env_vars() -> namedtuple:
-    EnvVars = namedtuple("EnvVars", ["mpm_port", "mpm_auth_token", "mpm_parent_pid"])
+def _fetch_and_validate_required_env_vars():
+    EnvVars = namedtuple(
+        "EnvVars", ["mpm_port", "mpm_auth_token", "mpm_parent_pid", "base_url_prefix"]
+    )
 
     port = os.getenv(mpm_env.get_env_name_mwi_mpm_port())
     mpm_auth_token = os.getenv(mpm_env.get_env_name_mwi_mpm_auth_token())
@@ -466,9 +514,13 @@ def _fetch_and_validate_required_env_vars() -> namedtuple:
         sys.exit(1)
 
     try:
+        base_url_prefix = os.getenv(mpm_env.get_env_name_base_url_prefix(), "")
         mwi_mpm_port: int = int(port)
         return EnvVars(
-            mpm_port=mwi_mpm_port, mpm_auth_token=mpm_auth_token, mpm_parent_pid=ctx
+            mpm_port=mwi_mpm_port,
+            mpm_auth_token=mpm_auth_token,
+            mpm_parent_pid=ctx,
+            base_url_prefix=base_url_prefix,
         )
     except ValueError as ve:
         log.error("Error: Invalid type for port: %s", ve)
@@ -480,7 +532,7 @@ def main() -> None:
     The main entry point of the application. Starts the app and run until the shutdown
     signal to terminate the app is received.
     """
-    env_vars: namedtuple = _fetch_and_validate_required_env_vars()
+    env_vars = _fetch_and_validate_required_env_vars()
     asyncio.run(start_app(env_vars))
 
 

matlab_proxy-0.25.1.dist-info/top_level.txt

@@ -1,3 +0,0 @@
-matlab_proxy
-matlab_proxy_manager
-tests

tests/integration/__init__.py

@@ -1 +0,0 @@
-# Copyright 2023-2024 The MathWorks, Inc.

tests/integration/integration_tests_with_license/__init__.py

@@ -1 +0,0 @@
-# Copyright 2023 The MathWorks, Inc.

tests/integration/integration_tests_with_license/conftest.py

@@ -1,47 +0,0 @@
-# Copyright 2023-2024 The MathWorks, Inc.
-
-import os
-from tests.integration.utils import integration_tests_utils as utils
-import pytest
-from matlab_proxy.util.mwi import environment_variables as mwi_env
-from tests.utils.logging_util import create_integ_test_logger
-
-
-_logger = create_integ_test_logger(
-    __name__, log_file_path=os.getenv("MWI_INTEG_TESTS_LOG_FILE_PATH")
-)
-
-
-@pytest.fixture(scope="module", name="module_monkeypatch")
-def monkeypatch_module_scope_fixture():
-    """
-    To ensure that modifications made with the monkeypatch fixture
-    persist across all tests in the module, this fixture
-    has been created in 'module' scope. This is done because a 'module'
-    scope object is needed with matlab-proxy 'module' scope fixture.
-    This allows us to patch certain aspects, like environment variables,
-    for all tests within the module.
-
-    Yields:
-        class object: Object of class MonkeyPatch
-    """
-    with pytest.MonkeyPatch.context() as mp:
-        yield mp
-
-
-@pytest.fixture(autouse=True, scope="module")
-def matlab_proxy_fixture(module_monkeypatch, request):
-    """
-    Pytest fixture for managing a standalone matlab-proxy process
-    for testing purposes. This fixture sets up a matlab-proxy process in
-    the module scope, and tears it down after all the tests are executed.
-    """
-
-    utils.perform_basic_checks()
-
-    module_monkeypatch.setenv(mwi_env.get_env_name_testing(), "false")
-    module_monkeypatch.setenv(mwi_env.get_env_name_development(), "false")
-    _logger.info("Started MATLAB Proxy process")
-
-    # Run the matlab proxy tests
-    yield

tests/integration/integration_tests_with_license/test_http_end_points.py

@@ -1,397 +0,0 @@
-# Copyright 2023-2025 The MathWorks, Inc.
-
-"""
-Contains integration tests which exercise HTTP endpoints of interest exposed by matlab-proxy-app
-"""
-
-# Imports
-from enum import Enum
-import json
-import os
-import pytest
-import re
-import requests
-import time
-from requests.adapters import HTTPAdapter, Retry
-from urllib.parse import urlparse, parse_qs
-
-# Local module imports
-import matlab_proxy.settings as settings
-from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
-from matlab_proxy.util import system
-from tests.integration.utils import integration_tests_utils as utils
-from tests.utils.logging_util import create_integ_test_logger
-
-# Logger Setup
-_logger = create_integ_test_logger(__name__)
-
-# Constants
-
-# Timeout for polling the matlab-proxy http endpoints
-# matlab proxy in Mac machines takes more time to be 'up'
-MAX_TIMEOUT = settings.get_process_startup_timeout()
-
-
-class Format(Enum):
-    """
-    An enumeration to specify different format types.
-
-    Attributes:
-        JSON (int): Represents the JSON format type.
-        TEXT (int): Represents the plain text format type.
-    """
-
-    JSON = 1
-    TEXT = 2
-
-
-# Utility Functions
-def _http_get_request(
-    uri, connection_scheme, headers, http_endpoint="", outputFormat=Format.TEXT
-):
-    """
-    Sends an HTTP GET request to a specified URI, optionally appending an endpoint to the URI.
-
-    This function uses a session with retries configured for transient network errors. It can return
-    the response in either text or JSON format, based on the outputFormat parameter.
-
-    Parameters:
-    - uri (str): The base URI for the HTTP request.
-    - connection_scheme (str): The scheme to use for the connection (e.g., 'http' or 'https').
-    - headers (dict): A dictionary of HTTP headers to include in the request.
-    - http_endpoint (str, optional): An additional endpoint to append to the base URI. Defaults to an empty string.
-    - outputFormat (format, optional): The desired format for the response content. This should be an attribute
-      of a format enumeration, supporting at least 'TEXT' and 'JSON' options. Defaults to Format.TEXT.
-
-    Returns:
-    - str or dict: The response content as a string if outputFormat is Format.TEXT, or as a dictionary
-      if outputFormat is Format.JSON.
-
-    Raises:
-    - Exception: If an invalid output format is specified.
-
-    Note:
-    - The function disables SSL certificate verification (`verify=False`). This may introduce security risks,
-      such as vulnerability to man-in-the-middle attacks. Use with caution in a production environment.
-    """
-    request_uri = uri + http_endpoint
-    with requests.Session() as s:
-        retries = Retry(total=10, backoff_factor=0.1)
-        s.mount(f"{connection_scheme}://", HTTPAdapter(max_retries=retries))
-        response = s.get(request_uri, headers=headers, verify=False)
-
-        if outputFormat == Format.TEXT:
-            return response.text
-        elif outputFormat == Format.JSON:
-            return json.loads(response.text)
-
-    raise Exception("Invalid output format specified.")
-
-
-def _check_matlab_status(matlab_proxy_app_fixture, status):
-    """
-    Check the status of a MATLAB session until a specified status is reached or a timeout occurs.
-
-    This function repeatedly sends HTTP GET requests to a MATLAB proxy application to check the current
-    status of MATLAB. It continues checking until MATLAB's status matches the specified target status or
-    until a maximum timeout is reached.
-
-    Parameters:
-    - matlab_proxy_app_fixture: An object containing configuration for connecting to the MATLAB proxy application.
-      This object must have the following attributes:
-        - url (str): The base URL of the MATLAB proxy application.
-        - connection_scheme (str): The scheme used for the connection (e.g., 'http' or 'https').
-        - headers (dict): A dictionary of HTTP headers to be sent with each request.
-    - status (str): The target status to wait for MATLAB to reach.
-
-    Returns:
-    - str: The status of MATLAB at the end of the function execution. This could be the target status if
-      it was reached within the timeout period, or the last known status of MATLAB if the timeout was reached
-      first.
-
-    Notes:
-    - The function waits for a maximum of MAX_TIMEOUT seconds, defined elsewhere, before exiting.
-    - It checks the MATLAB status every 1 second.
-    - The MATLAB status is obtained by sending a GET request to the '/get_status' endpoint of the proxy application.
-    - The response from the proxy application is expected to be in JSON format, with MATLAB's status accessible
-      via `res["matlab"]["status"]`.
-
-    Exceptions:
-    - This function may raise exceptions related to network issues or JSON parsing errors, which are not
-      explicitly handled within the function.
-    """
-    uri = matlab_proxy_app_fixture.url
-    connection_scheme = matlab_proxy_app_fixture.connection_scheme
-    headers = matlab_proxy_app_fixture.headers
-
-    matlab_status = None
-
-    start_time = time.time()
-    while matlab_status != status and (time.time() - start_time < MAX_TIMEOUT):
-        time.sleep(1)
-        res = _http_get_request(
-            uri,
-            connection_scheme,
-            headers,
-            http_endpoint="/get_status",
-            outputFormat=Format.JSON,
-        )
-        matlab_status = res["matlab"]["status"]
-
-    return matlab_status
-
-
-def _download_test_file(matlab_proxy_app_fixture, test_file):
-    """Returns result of hitting the /download endpoint for test_file.
-
-    Returns:
-        str: The contents of the test_file being downloaded through matlab-proxy.
-    """
-    uri = matlab_proxy_app_fixture.url
-    connection_scheme = matlab_proxy_app_fixture.connection_scheme
-    headers = matlab_proxy_app_fixture.headers
-
-    res = _http_get_request(
-        uri,
-        connection_scheme,
-        headers,
-        http_endpoint="/download/" + test_file,
-        outputFormat=Format.TEXT,
-    )
-    return res
-
-
-# Main Classes
-class RealMATLABServer:
-    """
-    Context Manager class which returns matlab proxy web server serving real MATLAB
-    for testing.
-
-    Setting up the server in the context of Pytest.
-    """
-
-    def __init__(self, event_loop):
-        self.event_loop = event_loop
-
-    def __enter__(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")
-
-        _logger.debug("Entering RealMATLABServer enter section.")
-        self.dpipe = os.pipe2(os.O_NONBLOCK) if system.is_linux() else os.pipe()
-        self.mwi_app_port = utils.get_random_free_port()
-        self.matlab_config_file_path = str(utils.get_matlab_config_file())
-
-        self.temp_dir_path = os.path.dirname(
-            os.path.dirname(self.matlab_config_file_path)
-        )
-
-        self.temp_dir_name = "temp_dir"
-        self.mwi_base_url = "/matlab-test"
-
-        # Environment variables to launch matlab proxy
-        input_env = {
-            "MWI_APP_PORT": self.mwi_app_port,
-            "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)
-        )
-
-        utils.wait_server_info_ready(self.mwi_app_port)
-        parsed_url = urlparse(utils.get_connection_string(self.mwi_app_port))
-
-        self.headers = {
-            MWI_AUTH_TOKEN_NAME_FOR_HTTP: (
-                parse_qs(parsed_url.query)[MWI_AUTH_TOKEN_NAME_FOR_HTTP][0]
-                if MWI_AUTH_TOKEN_NAME_FOR_HTTP in parse_qs(parsed_url.query)
-                else ""
-            )
-        }
-        self.connection_scheme = parsed_url.scheme
-        self.url = parsed_url.scheme + "://" + parsed_url.netloc + parsed_url.path
-        return self
-
-    async def _terminate_process(self, timeout=0):
-        """
-        Asynchronous helper method to terminate the process with a timeout.
-
-        Args:
-            timeout: Maximum number of seconds to wait
-                    for the process to terminate
-
-        """
-        import asyncio
-
-        process = self.proc
-        try:
-            process.terminate()
-            await asyncio.wait_for(process.wait(), timeout=timeout)
-        except asyncio.TimeoutError:
-            _logger.warning(
-                "Termination of the MATLAB Server process timed out. Attempting to kill."
-            )
-            process.kill()
-            await process.wait()
-            _logger.debug("Killed the MATLAB process after timeout.")
-
-    def __exit__(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))
-        _logger.debug("Terminated the MATLAB process.")
-
-
-# Fixtures
-@pytest.fixture
-def matlab_proxy_app_fixture(
-    event_loop,
-):
-    """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:
-            yield matlab_proxy_app
-    except ProcessLookupError as e:
-        _logger.debug("ProcessLookupError found in matlab proxy app fixture")
-        _logger.debug(e)
-
-
-@pytest.fixture
-def test_file_contents():
-    """
-    A pytest fixture that provides a string for testing purposes.
-
-    This fixture returns a predefined string that can be used in tests to simulate
-    the contents of a file or any scenario where a constant string value is needed.
-
-    Returns:
-        str: A string containing the text "I LOVE MATLAB."
-    """
-    return "I LOVE MATLAB."
-
-
-@pytest.fixture
-def test_file(tmp_path, test_file_contents):
-    """
-    A pytest fixture that creates a temporary test file with given contents.
-
-    This fixture utilizes pytest's `tmp_path` fixture to generate a temporary directory,
-    then creates a file named "temporary_test_file.txt" within this directory,
-    and writes the provided contents to this file. It is useful for tests that require
-    reading from or writing to files without affecting the actual file system.
-
-    Parameters:
-    - tmp_path (Path): A pytest fixture that provides a temporary directory unique to the test function.
-    - test_file_contents (str): The content to be written into the temporary test file.
-
-    Returns:
-    - str: The path to the created temporary test file as a string.
-    """
-    test_file = os.path.join(tmp_path, "temporary_test_file.txt")
-    with open(test_file, "w+") as f:
-        f.write(test_file_contents)
-    return test_file
-
-
-# Test Functions
-def test_matlab_is_up(matlab_proxy_app_fixture):
-    """Test that the status switches from 'starting' to 'up' within a timeout.
-
-    Args:
-        matlab_proxy_app_fixture: A pytest fixture which yields a real matlab server to be used by tests.
-    """
-
-    status = _check_matlab_status(matlab_proxy_app_fixture, "up")
-    assert status == "up"
-
-
-def test_stop_matlab(matlab_proxy_app_fixture):
-    """Test to check that matlab is in 'down' state when
-    we send the delete request to 'stop_matlab' endpoint
-
-    Args:
-        matlab_proxy_app_fixture: A pytest fixture which yields a real matlab server to be used by tests.
-    """
-    status = _check_matlab_status(matlab_proxy_app_fixture, "up")
-    assert status == "up"
-
-    http_endpoint_to_test = "/stop_matlab"
-    stop_url = matlab_proxy_app_fixture.url + http_endpoint_to_test
-
-    with requests.Session() as s:
-        retries = Retry(total=10, backoff_factor=0.1)
-        s.mount(
-            f"{matlab_proxy_app_fixture.connection_scheme}://",
-            HTTPAdapter(max_retries=retries),
-        )
-        s.delete(stop_url, headers=matlab_proxy_app_fixture.headers, verify=False)
-
-    status = _check_matlab_status(matlab_proxy_app_fixture, "down")
-    assert status == "down"
-
-
-async def test_print_message(matlab_proxy_app_fixture):
-    """Test if the right logs are printed
-
-    Args:
-        matlab_proxy_app_fixture: A pytest fixture which yields a real matlab server to be used by tests.
-
-    FIXME: If output has logging or extra debug info, 600 bytes might not be enough.
-    """
-    # Checks if matlab proxy is in "up" state or not
-    status = _check_matlab_status(matlab_proxy_app_fixture, "up")
-    assert status == "up"
-
-    uri_regex = f"{matlab_proxy_app_fixture.connection_scheme}://[a-zA-Z0-9\-_.]+:{matlab_proxy_app_fixture.mwi_app_port}{matlab_proxy_app_fixture.mwi_base_url}"
-
-    read_descriptor, write_descriptor = matlab_proxy_app_fixture.dpipe
-    number_of_bytes = 600
-
-    if read_descriptor:
-        line = os.read(read_descriptor, number_of_bytes).decode("utf-8")
-        process_logs = line.strip()
-
-    assert bool(re.search(uri_regex, process_logs)) == True
-
-    # Close the read and write descriptors.
-    os.close(read_descriptor)
-    os.close(write_descriptor)
-
-
-def test_download_file_from_matlab(
-    matlab_proxy_app_fixture, test_file, test_file_contents
-):
-    """
-    Test the downloading of a file from a MATLAB proxy application.
-
-    This test function checks if the MATLAB proxy application is up and running, and then attempts to download
-    a specific test file from it. It validates both the status of the MATLAB proxy and the contents of the downloaded file.
-
-    Parameters:
-    - matlab_proxy_app_fixture (fixture): A test fixture representing the MATLAB proxy application environment.
-    - test_file (str): The name or path of the test file to be downloaded from the MATLAB proxy application.
-    - test_file_contents (str): The expected contents of the test file to validate the download operation.
-
-    Assertions:
-    - Asserts that the MATLAB proxy application is "up".
-    - Asserts that the content of the downloaded file matches the expected `test_file_contents`.
-
-    Raises:
-    - AssertionError: If any of the assertions fail, indicating either the MATLAB proxy application is not running
-      as expected or there is a mismatch in the file content.
-    """
-    status = _check_matlab_status(matlab_proxy_app_fixture, "up")
-    assert status == "up"
-
-    # Once MATLAB is up, we can then attempt to download
-    result = _download_test_file(matlab_proxy_app_fixture, test_file)
-    assert result == test_file_contents

tests/integration/integration_tests_without_license/__init__.py

@@ -1 +0,0 @@
-# Copyright 2023 The MathWorks, Inc.