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

tests/integration/integration_tests_without_license/conftest.py

@@ -1,116 +0,0 @@
-# Copyright 2023-2024 The MathWorks, Inc.
-
-import pytest
-from tests.integration.utils import integration_tests_utils as utils
-import requests
-from tests.utils.logging_util import create_integ_test_logger
-import os
-from urllib.parse import urlparse, parse_qs
-from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
-
-_logger = create_integ_test_logger(__name__)
-
-
-@pytest.fixture(scope="module", name="module_monkeypatch")
-def monkeypatch_module_scope_fixture():
-    """
-    Pytest fixture for creating a monkeypatch object in 'module' scope.
-    The default monkeypatch fixture returns monkeypatch object in
-    'function' scope but a 'module' scope object is needed with matlab-proxy
-    'module' scope fixture.
-
-    Yields:
-        class object: Object of class MonkeyPatch
-    """
-    with pytest.MonkeyPatch.context() as mp:
-        yield mp
-
-
-@pytest.fixture
-def parse_matlab_proxy_url():
-    # Get the base URL from a utility function or environment variable
-    mwi_app_port = os.environ["MWI_APP_PORT"]
-
-    # Construct the parameters dictionary
-    parsed_url = urlparse(utils.get_connection_string(mwi_app_port))
-
-    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 ""
-        )
-    }
-    connection_scheme = parsed_url.scheme
-
-    # Return the base URL and parameters as a tuple
-    return parsed_url, headers, connection_scheme
-
-
-@pytest.fixture(scope="module", autouse=True)
-def start_matlab_proxy_fixture(module_monkeypatch):
-    """Starts the matlab proxy process"""
-    utils.perform_basic_checks()
-
-    # Start matlab-proxy-app for testing
-
-    mwi_app_port = utils.get_random_free_port()
-    mwi_base_url = "/matlab-test"
-
-    input_env = {
-        "MWI_APP_PORT": mwi_app_port,
-        "MWI_BASE_URL": mwi_base_url,
-    }
-
-    import shutil
-    import matlab_proxy
-
-    matlab_config_file = str(
-        utils.get_matlab_config_file()
-    )  # ~/.matlab/MWI/hosts/hostname/proxy_app_config.json
-
-    _logger.info(f"matlab_config_file {matlab_config_file}")
-
-    dotmatlab_dir_path = os.path.dirname(os.path.dirname(matlab_config_file))
-
-    # Create a temporary location in .matlab directory
-    temp_dir_path = os.path.join(dotmatlab_dir_path, "temp_dir")
-    os.mkdir(temp_dir_path)  # delete this folder after the test execution
-    shutil.move(matlab_config_file, temp_dir_path)
-
-    loop = matlab_proxy.util.get_event_loop()
-
-    # Run matlab-proxy in the background in an event loop
-    proc = loop.run_until_complete(utils.start_matlab_proxy_app(input_env=input_env))
-    _logger.info("Started MATLAB Proxy process")
-
-    # Wait for mwi_server.info file to be ready
-    utils.wait_server_info_ready(mwi_app_port)
-
-    # Get the scheme on which MATLAB Proxy connection string
-    matlab_proxy_url = utils.get_connection_string(mwi_app_port)
-
-    utils.poll_web_service(
-        matlab_proxy_url,
-        step=5,
-        timeout=120,
-        ignore_exceptions=(
-            requests.exceptions.ConnectionError,
-            requests.exceptions.SSLError,
-        ),
-    )
-
-    for key, value in input_env.items():
-        module_monkeypatch.setenv(key, value)
-
-    yield
-    from pathlib import Path
-
-    shutil.move(
-        str(temp_dir_path / Path("proxy_app_config.json")),
-        str(os.path.dirname(matlab_config_file)),
-    )
-    shutil.rmtree(temp_dir_path)
-
-    proc.terminate()
-    loop.run_until_complete(proc.wait())

tests/integration/integration_tests_without_license/test_matlab_is_down_if_unlicensed.py

@@ -1,49 +0,0 @@
-# Copyright 2023-2024 The MathWorks, Inc.
-
-import os
-import json
-import requests
-from requests.adapters import HTTPAdapter, Retry
-from tests.integration.utils import integration_tests_utils as utils
-from urllib.parse import urlparse
-from tests.utils.logging_util import create_integ_test_logger
-
-_logger = create_integ_test_logger(log_name=__name__)
-
-
-def test_matlab_down(parse_matlab_proxy_url):
-    """Test that matlab is down and no license is picked up"""
-
-    parsed_url, headers, connection_scheme = parse_matlab_proxy_url
-    http_endpoint = "/get_status"
-    uri = (
-        connection_scheme + "://" + parsed_url.netloc + parsed_url.path + http_endpoint
-    )
-
-    json_response = None
-
-    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(uri, headers=headers, verify=False)
-        json_response = json.loads(response.text)
-
-    matlab_status = json_response["matlab"]["status"]
-    assert matlab_status == "down"
-
-
-def test_matlab_proxy_app_installed():
-    import shutil
-
-    """Test that the executable matlab_proxy_app is located on PATH and executable"""
-
-    which_matlabproxyapp = shutil.which("matlab-proxy-app")
-    assert (
-        which_matlabproxyapp is not None
-    ), "matlab-proxy-app does not exist in system path"
-    assert (
-        os.access(which_matlabproxyapp, os.R_OK) == True
-    ), """matlab-proxy-app does not have the read permissions"""
-    assert (
-        os.access(which_matlabproxyapp, os.X_OK) == True
-    ), """matlab-proxy-app does not have the execute permissions"""

tests/integration/utils/__init__.py

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

tests/integration/utils/integration_tests_utils.py

@@ -1,352 +0,0 @@
-# Copyright 2023-2024 The MathWorks, Inc.
-# Utility functions for integration testing of matlab-proxy
-
-import asyncio
-import os
-import socket
-import time
-import urllib3
-import requests
-import json
-from tests.utils.logging_util import create_integ_test_logger
-
-_logger = create_integ_test_logger(__name__)
-
-
-def perform_basic_checks():
-    """
-    Perform basic checks for the prerequisites for starting
-    matlab-proxy
-    """
-    import matlab_proxy.settings
-
-    _logger.info("Performing basic checks for matlab-proxy")
-
-    # Validate MATLAB before testing
-    _, matlab_path = matlab_proxy.settings.get_matlab_executable_and_root_path()
-
-    # Check if MATLAB is in the system path
-    assert matlab_path is not None, "MATLAB is not in system path"
-
-    # Check if MATLAB verison is >= R2020b
-    assert (
-        matlab_proxy.settings.get_matlab_version(matlab_path) >= "R2020b"
-    ), "MATLAB version should be R2020b or later"
-    _logger.debug("Exiting perform_basic_checks")
-
-
-def matlab_proxy_cmd_for_testing():
-    """
-    Get command for starting matlab-proxy process
-
-    Returns:
-        list(string): Command for starting matlab-proxy process
-    """
-
-    import matlab_proxy
-
-    matlab_cmd = [matlab_proxy.get_executable_name()]
-
-    return matlab_cmd
-
-
-async def start_matlab_proxy_app(out=asyncio.subprocess.PIPE, input_env={}):
-    """
-    Starts matlab-proxy as a subprocess. The subprocess runs forever unless
-    there is any error
-
-    Args:
-        input_env (dict, optional): Environment variables to be
-        initialized for the subprocess. Defaults to {}.
-
-    Returns:
-        Process: subprocess object
-    """
-    from matlab_proxy.util import system
-
-    _logger.info("Starting MATLAB Proxy app")
-    cmd = matlab_proxy_cmd_for_testing()
-    matlab_proxy_env = os.environ.copy()
-    matlab_proxy_env.update(input_env)
-
-    proc = await asyncio.create_subprocess_exec(
-        *cmd,
-        env=matlab_proxy_env,
-        stdout=out,
-        stderr=out,
-    )
-    _logger.debug("MATLAB Proxy App started")
-    return proc
-
-
-def send_http_request(
-    connection_scheme,
-    mwi_app_port,
-    mwi_base_url="",
-    http_endpoint="",
-    method="GET",
-    headers={},
-):
-    """Send HTTP request to matlab-proxy server.
-    Returns HTTP response JSON"""
-
-    uri = (
-        f"{connection_scheme}://localhost:{mwi_app_port}{mwi_base_url}/{http_endpoint}"
-    )
-
-    with urllib3.PoolManager(
-        retries=urllib3.Retry(backoff_factor=0.1, backoff_max=300)
-    ) as http:
-        res = http.request(method, uri, fields=headers)
-        return json.loads(res.data.decode("utf-8"))
-
-
-def wait_matlab_proxy_ready(matlab_proxy_url):
-    """
-    Wait for matlab-proxy to be up and running
-
-    Args:
-        matlab_proxy_url (string): URL to access matlab-proxy
-    """
-
-    from matlab_proxy.util import system
-    import matlab_proxy.settings as settings
-
-    _logger.info("Wait for MATLAB Proxy to start")
-    # Wait until the matlab config file is created
-    MAX_TIMEOUT = settings.get_process_startup_timeout()
-    start_time = time.time()
-
-    while not os.path.exists(str(get_matlab_config_file())) and (
-        time.time() - start_time < MAX_TIMEOUT
-    ):
-        time.sleep(1)
-
-    try:
-        if not os.path.exists(str(get_matlab_config_file())):
-            raise FileNotFoundError("Config file is not present on the path")
-
-    except FileNotFoundError as e:
-        _logger.exception("Config file does not exist")
-        _logger.exception(e)
-
-
-def get_random_free_port() -> str:
-    """
-    Get a random free port
-
-    Returns:
-        string: A random free port
-    """
-
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    s.bind(("", 0))
-    port = str(s.getsockname()[1])
-    s.close()
-    return port
-
-
-def wait_server_info_ready(port_number):
-    """
-    Waits for server file to be available on the disk
-    """
-
-    import matlab_proxy.settings as settings
-
-    # timeout_value is in seconds
-    timeout_value = 60
-    start_time = time.time()
-    config_folder = settings.get_mwi_config_folder()
-    _path = config_folder / "ports" / port_number / "mwi_server.info"
-
-    while time.time() - start_time < timeout_value:
-        if _path.exists():
-            return True
-
-        time.sleep(1)
-
-    raise FileNotFoundError("mwi_server.info file does not exist")
-
-
-def license_matlab_proxy(matlab_proxy_url):
-    """
-    Use Playwright UI automation to license matlab-proxy.
-    Uses TEST_USERNAME and TEST_PASSWORD from environment variables.
-
-    Args:
-        matlab_proxy_url (string): URL to access matlab-proxy
-    """
-    from playwright.sync_api import sync_playwright, expect
-
-    _logger.info("Licensing MATLAB using matlab-proxy")
-    # These are MathWorks Account credentials to license MATLAB
-    # Throws 'KeyError' if the following environment variables are not set
-    TEST_USERNAME = os.environ["TEST_USERNAME"]
-    TEST_PASSWORD = os.environ["TEST_PASSWORD"]
-
-    with sync_playwright() as playwright:
-        browser = playwright.chromium.launch(headless=True)
-        context = browser.new_context(ignore_https_errors=True)
-
-        page = context.new_page()
-
-        page.goto(matlab_proxy_url)
-
-        # Find the MHLM licensing windows in matlab-proxy
-        mhlm_div = page.locator("#MHLM")
-        expect(
-            mhlm_div,
-            "Wait for MHLM licensing window to appear. This might fail if the MATLAB is already licensed",
-        ).to_be_visible(timeout=60000)
-
-        # The login iframe is present within the MHLM Div
-        login_iframe = mhlm_div.frame_locator("#loginframe")
-
-        # Fills in the username textbox
-        email_text_box = login_iframe.locator("#userId")
-        expect(
-            email_text_box,
-            "Wait for email ID textbox to appear",
-        ).to_be_visible(timeout=20000)
-        email_text_box.fill(TEST_USERNAME)
-        email_text_box.press("Enter")
-
-        # Fills in the password textbox
-        password_text_box = login_iframe.locator("#password")
-        expect(password_text_box, "Wait for password textbox to appear").to_be_visible(
-            timeout=20000
-        )
-        password_text_box.fill(TEST_PASSWORD)
-        password_text_box.press("Enter")
-
-        # Verifies if licensing is successful by checking the status information
-        status_info = page.get_by_text("Status Information")
-        expect(
-            status_info,
-            "Verify if Licensing is successful. This might fail if incorrect credentials are provided",
-        ).to_be_visible(timeout=60000)
-        _logger.debug("Succeeded in licensing MATLAB using matlab-proxy")
-        browser.close()
-
-
-def unlicense_matlab_proxy(matlab_proxy_url):
-    """
-    Unlicense matlab-proxy that is licensed using online licensing
-
-    Args:
-        matlab_proxy_url (string): URL to access matlab-proxy
-    """
-    import warnings
-
-    _logger.info("Unlicensing matlab-proxy")
-    max_retries = 3  # Max retries for unlicensing matlab-proxy
-    retries = 0
-
-    while retries < max_retries:
-        error = None
-        try:
-            resp = requests.delete(
-                matlab_proxy_url + "/set_licensing_info", headers={}, verify=False
-            )
-
-            if resp.status_code == requests.codes.OK:
-                data = resp.json()
-                assert data["licensing"] == None, "matlab-proxy licensing is not unset"
-                assert (
-                    data["matlab"]["status"] == "down"
-                ), "matlab-proxy is not in 'stopped' state"
-
-                # Throw warning if matlab-proxy is unlicensed but with some error
-                if data["error"] != None:
-                    warnings.warn(
-                        f"matlab-proxy is unlicensed but with error: {data['error']}",
-                        UserWarning,
-                    )
-                _logger.debug("Succeeded in unlicensing matlab-proxy")
-                break
-            else:
-                resp.raise_for_status()
-        except Exception as e:
-            error = e
-        finally:
-            retries += 1
-
-    # If the above code threw error even after maximum retries, then raise error
-    if error:
-        raise error
-
-
-def get_connection_string(port_number):
-    """Returns the scheme on which matlab proxy starts (http or https)
-
-    Args:
-        port_number (string): Port on which MATLAB proxy starts
-
-    Returns:
-        scheme: String representing the scheme
-    """
-    import matlab_proxy.settings as settings
-
-    config_folder = settings.get_mwi_config_folder()
-    _path = config_folder / "ports" / port_number / "mwi_server.info"
-    conn_string = None
-
-    try:
-        with open(_path, "r") as _file:
-            conn_string = _file.readline().rstrip()
-
-    except FileNotFoundError:
-        _logger.exception(f"{_path} does not exist")
-
-    return conn_string
-
-
-def poll_web_service(url, step=1, timeout=60, ignore_exceptions=None):
-    """Poll a web service for a 200 response
-
-    Args:
-        url (string): URL of the web service
-        step (int, optional): Poll Interval. Defaults to 1 second.
-        timeout (int, optional): Polling timout. Defaults to 60 seconds.
-        ignore_exceptions (tuple, optional): The exceptions that need to be ignored
-        within the polling timout. Defaults to None.
-
-    Raises:
-        TimeoutError: Error if polling timeout is exceeded
-
-    Returns:
-        dict: response dictionary object
-    """
-    start_time = time.time()
-    end_time = start_time + timeout
-
-    import matlab_proxy.settings as settings
-
-    config_folder = settings.get_mwi_config_folder()
-
-    while time.time() < end_time:
-        try:
-            response = requests.get(url, verify=False)
-            if response.status_code == 200:
-                return response
-
-        except Exception as e:
-            if ignore_exceptions and isinstance(e, ignore_exceptions):
-                continue  # Ignore specified exceptions
-        time.sleep(step)
-
-    raise TimeoutError(
-        f"{url} did not return a 200 response within the timeout period {timeout} seconds."
-    )
-
-
-def get_matlab_config_file():
-    """
-    Gets the path to MATLAB config file generated by matlab-proxy
-
-    Returns:
-        string: MATLAB config file path
-    """
-    from matlab_proxy import settings
-
-    return settings.get()["matlab_config_file"]

tests/integration/utils/licensing.py

@@ -1,152 +0,0 @@
-# Copyright 2024 The MathWorks, Inc.
-import os
-import logging
-from playwright.sync_api import Page, Error, sync_playwright, expect
-from tests.integration.utils import integration_tests_utils as utils
-from tests.utils.logging_util import create_integ_test_logger
-
-# Configure logging
-_logger = create_integ_test_logger(__name__)
-
-TIMEOUTS = {
-    # Time in milliseconds
-    "MHLM_VISIBLE": 60 * 1000,
-    "TEXTBOX_VISIBLE": 5 * 1000,
-    "MATLAB_STARTS": 3 * 60 * 1000,
-}
-
-
-POLL_INTERVAL = 1000
-
-
-def _get_matlab_proxy_url():
-    # import integration_tests_utils as utils
-    import matlab_proxy.util
-
-    mwi_app_port = utils.get_random_free_port()
-    mwi_base_url = "/matlab-test"
-
-    input_env = {
-        "MWI_APP_PORT": mwi_app_port,
-        "MWI_BASE_URL": mwi_base_url,
-    }
-
-    loop = matlab_proxy.util.get_event_loop()
-    # Run matlab-proxy in the background in an event loop
-    proc = loop.run_until_complete(utils.start_matlab_proxy_app(input_env=input_env))
-
-    utils.wait_server_info_ready(mwi_app_port)
-    matlab_proxy_url = utils.get_connection_string(mwi_app_port)
-    return matlab_proxy_url, proc, loop
-
-
-def license_matlab_proxy():
-    import requests
-
-    matlab_proxy_url, proc, loop = _get_matlab_proxy_url()
-
-    utils.poll_web_service(
-        matlab_proxy_url,
-        step=5,
-        timeout=120,
-        ignore_exceptions=(
-            requests.exceptions.ConnectionError,
-            requests.exceptions.SSLError,
-        ),
-    )
-
-    licensing_with_online_licensing(matlab_proxy_url)
-    utils.wait_matlab_proxy_ready(matlab_proxy_url)
-    proc.terminate()
-    loop.run_until_complete(proc.wait())
-
-
-def licensing_with_online_licensing(matlab_proxy_url):
-    """
-    Use Playwright UI automation to license matlab-proxy.
-    Uses TEST_USERNAME and TEST_PASSWORD from environment variables.
-
-    Args:
-        matlab_proxy_url (string): URL to access matlab-proxy
-    """
-    from playwright.sync_api import sync_playwright, expect
-
-    # These are MathWorks Account credentials to license MATLAB
-    # Throws 'KeyError' if the following environment variables are not set
-    TEST_USERNAME = os.environ["TEST_USERNAME"]
-    TEST_PASSWORD = os.environ["TEST_PASSWORD"]
-
-    playwright, browser, page = _launch_browser()
-    page.goto(matlab_proxy_url)
-
-    # Find the MHLM licensing window in matlab-proxy
-    login_iframe = _wait_for_login_iframe(page)
-
-    # Fills in the username textbox
-    email_text_box = _fill_in_username(TEST_USERNAME, login_iframe)
-    email_text_box.press("Enter")
-
-    # Fills in the password textbox
-    password_text_box = _fill_in_password(TEST_PASSWORD, login_iframe)
-    password_text_box.press("Enter")
-
-    # Verifies if licensing is successful by checking the status information
-    _verify_licensing(page)
-    _close_resources(playwright, browser)
-
-
-def _verify_licensing(page):
-    status_info = page.get_by_text("Status Information")
-    expect(
-        status_info,
-        "Verify if Licensing is successful. This might fail if incorrect credentials are provided",
-    ).to_be_visible(timeout=TIMEOUTS["MHLM_VISIBLE"])
-
-
-def _wait_for_login_iframe(matlab_proxy_page):
-    """Waits for the MHLM/Online Licensing form to appear."""
-    mhlm_div = matlab_proxy_page.locator("#MHLM")
-    expect(
-        mhlm_div,
-        "Wait for MHLM licensing window to appear. This might fail if the MATLAB is already licensed",
-    ).to_be_visible(timeout=TIMEOUTS["MHLM_VISIBLE"])
-
-    # The login iframe is present within the MHLM Div
-    login_iframe = mhlm_div.frame_locator("#loginframe")
-    return login_iframe
-
-
-def _launch_browser(headless: bool = True) -> tuple:
-    """Launches the browser and returns the browser and page objects."""
-    playwright = sync_playwright().start()
-    browser = playwright.chromium.launch(headless=headless)
-    context = browser.new_context(ignore_https_errors=True)
-    page = context.new_page()
-    return playwright, browser, page
-
-
-def _close_resources(playwright, browser):
-    """Closes the browser and playwright resources properly."""
-    browser.close()
-    playwright.stop()
-
-
-def _fill_in_username(username, login_iframe):
-    """Inputs the provided username string into the MHLM login form."""
-    email_text_box = login_iframe.locator("#userId")
-    expect(
-        email_text_box,
-        "Wait for email ID textbox to appear",
-    ).to_be_visible(timeout=TIMEOUTS["TEXTBOX_VISIBLE"])
-    email_text_box.fill(username)
-    return email_text_box
-
-
-def _fill_in_password(password, login_iframe):
-    """Inputs the provided password string into the MHLM login form."""
-    password_text_box = login_iframe.locator("#password")
-    expect(password_text_box, "Wait for password textbox to appear").to_be_visible(
-        timeout=TIMEOUTS["TEXTBOX_VISIBLE"]
-    )
-    password_text_box.fill(password)
-    return password_text_box

tests/unit/__init__.py

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