matlab-proxy 0.26.0__py3-none-any.whl → 0.27.1__py3-none-any.whl

tests/unit/util/mwi/embedded_connector/test_helpers.py

@@ -1,29 +0,0 @@
-# Copyright 2022 The MathWorks, Inc.
-
-from matlab_proxy.util import mwi
-
-
-def test_get_data_to_eval_mcode():
-    necessary_keys = ["uuid", "messages", "computeToken"]
-    mcode = "exit"
-    data = mwi.embedded_connector.helpers.get_data_to_eval_mcode(mcode)
-
-    assert set(necessary_keys).issubset(set(data.keys()))
-    assert data["messages"]["Eval"][0]["mcode"] == mcode
-
-
-def test_get_data_to_feval_mcode():
-    necessary_keys = ["uuid", "messages", "computeToken"]
-    m_function = "round"
-    args = [3.135, 2]
-    nargout = 2
-    data = mwi.embedded_connector.helpers.get_data_to_feval_mcode(
-        m_function, *args, nargout=nargout
-    )
-
-    assert set(necessary_keys).issubset(set(data.keys()))
-    feval_data = data["messages"]["FEval"][0]
-
-    assert feval_data["function"] == m_function
-    assert feval_data["arguments"] == args
-    assert feval_data["nargout"] == nargout

tests/unit/util/mwi/embedded_connector/test_request.py

@@ -1,64 +0,0 @@
-# Copyright 2022-2023 The MathWorks, Inc.
-
-import pytest
-from matlab_proxy.util import mwi
-from matlab_proxy.util.mwi.exceptions import EmbeddedConnectorError
-from tests.unit.util import MockResponse
-
-
-async def test_send_request_success(mocker):
-    """Test to check the happy path for send_request
-    Args:
-        mocker : Built in pytest fixture
-    """
-    # Arrange
-    json_data = {"hello": "world"}
-    payload = json_data
-    mock_resp = MockResponse(payload=payload, ok=True)
-    _ = mocker.patch("aiohttp.ClientSession.request", return_value=mock_resp)
-
-    # Act
-    res = await mwi.embedded_connector.send_request(
-        url="https://localhost:3000", data=json_data, method="GET"
-    )
-
-    # Assert
-    assert json_data["hello"] == res["hello"]
-
-
-async def test_send_request_failure(mocker):
-    """Test to check if send_request fails when
-    1) EC does not respond
-    2) url or method is not supplied
-    Args:
-        mocker : Built in pytest fixture
-    """
-
-    # Arrange
-    json_data = {"hello": "world"}
-
-    payload = json_data
-    mock_resp = MockResponse(payload=payload, ok=False)
-    _ = mocker.patch("aiohttp.ClientSession.request", return_value=mock_resp)
-
-    # Doesnt have url or data or method
-    mock_resp = MockResponse(payload=payload, ok=False)
-
-    # Act
-
-    # Failed to communicate with EmbeddedConnector
-    with pytest.raises(EmbeddedConnectorError):
-        _ = await mwi.embedded_connector.send_request(
-            url="https://localhost:3000", method="GET", data=json_data
-        )
-
-    for key in ["url", "method"]:
-        options = {
-            "url": "https://localhost:3000",
-            "data": json_data,
-            "method": "GET",
-        }
-        options[key] = ""
-        # Assert
-        with pytest.raises(EmbeddedConnectorError):
-            _ = await mwi.embedded_connector.send_request(**options)

tests/unit/util/mwi/test_custom_http_headers.py

@@ -1,281 +0,0 @@
-# Copyright 2020-2022 The MathWorks, Inc.
-
-import json
-import os
-import stat
-import time
-from json.decoder import JSONDecodeError
-
-import pytest
-from matlab_proxy.util import system
-from matlab_proxy.util.mwi import custom_http_headers
-from matlab_proxy.util.mwi import environment_variables as mwi_env
-
-
-def test_get_custom_header_env_var():
-    """Test to check if the __get_custom_header_env_var() method returns the expected environment variable name"""
-    assert (
-        mwi_env.get_env_name_custom_http_headers()
-        == custom_http_headers.__get_custom_header_env_var()
-    )
-
-
-def test_get_exception_statement():
-    """Test to check if __get_exception_statement() contains 'JSON data' in the generic exception statement returned by __get_exception_statement()"""
-    assert "JSON data" in custom_http_headers.__get_exception_statement()
-
-
-@pytest.fixture(name="non_existent_temp_json_file")
-def non_existent_random_json_file_fixture(tmp_path):
-    """Pytest fixture which returns a non-existent random json file within a temporary directory
-
-    Args:
-        tmp_path : Built in Pytest fixture.
-
-    Returns:
-        PosixPath: of the non-existent random json file.
-    """
-    random_file = tmp_path / f'{str(time.time()).replace(".", "")}.json'
-    return random_file
-
-
-@pytest.fixture(name="monkeypatch_env_var_with_json_file")
-def monkeypatch_env_var_with_json_file_fixture(
-    monkeypatch, non_existent_temp_json_file
-):
-    """Pytest fixture which monkeypatches the env variable returned by the __get_custom_header_env_var()
-    method with the value returned by the pytest fixture non_existent_tmp_json_file
-
-    Args:
-        monkeypatch : Built in pytest fixture
-        non_existent_temp_json_file: Pytest fixture which returns a string containing path
-                                        to non-existent file in a temporary directory.
-    """
-    monkeypatch.setenv(
-        mwi_env.get_env_name_custom_http_headers(),
-        str(non_existent_temp_json_file),
-    )
-
-
-@pytest.fixture(name="valid_json_content")
-def valid_json_content_fixture():
-    """Pytest fixture which returns valid JSON data as a string
-
-    Returns:
-        [String]: containing valid JSON data.
-    """
-    return '{"abcd": "hello"}'
-
-
-@pytest.fixture(name="json_file_with_valid_json")
-def json_file_with_valid_json_fixture(non_existent_temp_json_file, valid_json_content):
-    """Pytest fixture which returns a random json file containing valid json data
-
-    Args:
-        non_existent_temp_json_file : Pytest fixture which returns a non-existent random json file.
-        valid_json_content : Pytest fixture which returns valid JSON data as a string.
-
-    Returns:
-        [PosixPath]: Of a random json file containing valid json data.
-    """
-    json_file_with_valid_content = non_existent_temp_json_file
-    with open(json_file_with_valid_content, "w") as f:
-        f.write(valid_json_content)
-
-    return json_file_with_valid_content
-
-
-def test_get_file_contents_with_valid_json(json_file_with_valid_json):
-    """Test to check if __get_file_contents() returns valid json data as a dict from a file
-
-    Args:
-        json_file_with_valid_json : Pytest fixture which returns a non-existent random json file.
-    """
-    file_content = None
-    with open(json_file_with_valid_json, "r") as f:
-        file_content = json.load(f)
-
-    assert file_content == custom_http_headers.__get_file_contents(
-        json_file_with_valid_json
-    )
-
-
-@pytest.fixture(name="invalid_json_content")
-def invalid_json_content_fixture():
-    """Pytest fixture which returns invalid json data as a string
-
-    Returns:
-        [String]: containing invalid json data.
-    """
-    return '{"abcd"= "hello"}'
-
-
-@pytest.fixture(name="json_file_with_invalid_json")
-def json_file_with_invalid_json_fixture(
-    non_existent_temp_json_file, invalid_json_content
-):
-    """Pytest fixture which returns a path to a random json file containing invalid json data.
-
-    Args:
-        non_existent_temp_json_file : Pytest fixture which returns a non-existent random json file.
-        invalid_json_content : Pytest fixture which returns invalid json data as a string.
-
-    Returns:
-        PosixPath: to a random file containing invalid json data.
-    """
-    json_file_with_invalid_content = non_existent_temp_json_file
-    with open(json_file_with_invalid_content, "w") as f:
-        f.write(invalid_json_content)
-
-    return json_file_with_invalid_content
-
-
-def test_get_file_contents_with_invalid_json(json_file_with_invalid_json, capsys):
-    """Test to check __get_file_contents() raises JSONDecodeError when invalid json data is present in a file.
-
-    Args:
-        json_file_with_invalid_json : Pytest fixture which returns a non-existent random json file.
-    """
-    with pytest.raises(SystemExit):
-        custom_http_headers.__get_file_contents(json_file_with_invalid_json)
-        out, err = capsys.readouterr()
-        assert JSONDecodeError.__name__ in out
-
-
-def test_check_file_validity_no_read_access(non_existent_temp_json_file, capsys):
-    """Test to check if OSError is raised when trying to read file with no read access.
-
-    Args:
-        non_existent_temp_json_file : Pytest fixture which returns a non-existent random json file.
-    """
-    temp_json_file_no_read_access = non_existent_temp_json_file
-
-    # Not possible to create a file in windows without read permission
-    # So not creating the file itself to check for SystemExit exception.
-    if not system.is_windows():
-        temp_json_file_no_read_access.touch(mode=stat.S_IWUSR)
-
-    with pytest.raises(SystemExit):
-        custom_http_headers.__check_file_validity(temp_json_file_no_read_access)
-        out, err = capsys.readouterr()
-        assert OSError.__name__ in out
-
-
-def test_check_file_validity_no_error(non_existent_temp_json_file, valid_json_content):
-    """Test to check __check_file_validity() does not raise any exception when the custom headers file
-    exists, has valid JSON data and the current python process has read access to the file.
-
-    Args:
-        non_existent_temp_json_file : Pytest fixture which returns a non-existent random json file.
-    """
-
-    random_json_file_with_valid_content = non_existent_temp_json_file
-    with open(random_json_file_with_valid_content, "w") as f:
-        f.write(valid_json_content)
-
-    assert (
-        custom_http_headers.__check_file_validity(random_json_file_with_valid_content)
-        is True
-    )
-
-
-def test_get_no_env_var():
-    """Test to check if get() returns an empty dict, when mwi_custom_http_headers env variable is not present."""
-    assert custom_http_headers.get() == dict()
-
-
-def test_get_with_json_file_no_error(
-    monkeypatch_env_var_with_json_file, valid_json_content
-):
-    """Test to check if expected json content is returned by get() as a dict when the
-    environment variable returned by __get_custom_header_env_var() contains a path to a JSON file
-
-    Args:
-        monkeypatch_env_var_with_json_file : Pytest fixture which monkeypatches the env variable returned by __get_custom_header_env_var() to
-                              have a non-existent temporary json file.
-        valid_json_content : Pytest fixture which returns valid json data as a string.
-    """
-    tmp_file_path = os.getenv(mwi_env.get_env_name_custom_http_headers())
-
-    with open(tmp_file_path, "w") as f:
-        f.write(valid_json_content)
-
-    assert custom_http_headers.get() == json.loads(valid_json_content)
-
-
-def test_get_with_json_file_raise_exception(
-    monkeypatch_env_var_with_json_file, invalid_json_content, capsys
-):
-    """Test to check if the get() method raises SystemExit exception when the environment variable returned by __get_custom_env_var()
-    contains path to a file with invalid JSON data. Also asserts for JSONDecodeError in stdout.
-
-    Args:
-        monkeypatch_env_var_with_json_file : Pytest fixture which monkeypatches the env variable returned by __get_custom_header_env_var() to
-                              have a non-existent temporary json file.
-        invalid_json_content : Pytest fixture which returns invalid json data as a string.
-    """
-    tmp_file_path = os.getenv(mwi_env.get_env_name_custom_http_headers())
-
-    with open(tmp_file_path, "w") as f:
-        f.write(invalid_json_content)
-
-    with pytest.raises(SystemExit):
-        custom_http_headers.get()
-        out, err = capsys.readouterr()
-        assert JSONDecodeError.__name__ in out
-
-
-@pytest.fixture(name="monkeypatch_env_var_with_invalid_json_string")
-def monkeypatch_env_var_with_invalid_json_string_fixture(
-    monkeypatch, invalid_json_content
-):
-    """Pytest fixture which monkeypatches the env variable returned by the __get_custom_header_env_var()
-    method with the value returned by the pytest fixture non_existent_temp_json_file
-
-    Args:
-        monkeypatch : Built in pytest fixture
-        non_existent_temp_json_file: Pytest fixture which returns a string containing path
-                                        to non-existent file in a temporary directory.
-    """
-    monkeypatch.setenv(mwi_env.get_env_name_custom_http_headers(), invalid_json_content)
-
-
-def test_get_with_invalid_json_string(
-    monkeypatch_env_var_with_invalid_json_string, capsys
-):
-    """Test to check if the get() method raises SystemExit exception when the environment variable returned by __get_custom_env_var()
-    contains invalid JSON data as a string. Also asserts for JSONDecodeError in stdout.
-
-    Args:
-        monkeypatch_env_var_with_invalid_json_string : Pytest fixture which monkeypatches the env variable returned by __get_custom_header_env_var() to
-                                                     contain invalid JSON data as a string.
-    """
-    with pytest.raises(SystemExit):
-        headers = custom_http_headers.get()
-        out, err = capsys.readouterr()
-        assert JSONDecodeError.__name__ in out
-
-
-@pytest.fixture(name="monkeypatch_env_var_with_valid_json_string")
-def monkeypatch_env_var_with_valid_json_string_fixture(monkeypatch, valid_json_content):
-    """Pytest fixture which monkeypatches the env variable returned by the __get_custom_header_env_var()
-    method with the value returned by the pytest fixture non_existent_tmp_json_file
-
-    Args:
-        monkeypatch : Built in pytest fixture
-        non_existent_temp_json_file: Pytest fixture which returns a string containing path
-                                        to non-existent file in a temporary directory.
-    """
-    monkeypatch.setenv(mwi_env.get_env_name_custom_http_headers(), valid_json_content)
-
-
-def test_get_with_valid_json_string(monkeypatch_env_var_with_valid_json_string):
-    """Test to check if expected json content is returned by get() as a dict when the
-    environment variable contains valid JSON data as a string
-
-    Args:
-        monkeypatch_env_var_with_valid_json_string : Pytest fixture which monkeypatches the env variable returned by __get_custom_header_env_var() to
-                                                     contain valid JSON data as a string.
-    """
-    headers = json.loads(os.getenv(mwi_env.get_env_name_custom_http_headers()))
-    assert headers == custom_http_headers.get()

tests/unit/util/mwi/test_download.py

@@ -1,152 +0,0 @@
-# Copyright 2024 The MathWorks, Inc.
-import pytest
-
-from matlab_proxy.util.mwi.download import (
-    _get_download_payload_path,
-    get_download_url,
-    is_download_request,
-)
-
-
-# Mock the request object
-@pytest.fixture
-def mock_request_fixture(mocker):
-    mock_req = mocker.MagicMock()
-    mock_req.app = {
-        "settings": {"base_url": ""},
-        "state": mocker.MagicMock(),
-    }
-    mock_req.rel_url = mocker.MagicMock()
-    return mock_req
-
-
-def _get_expected_output_based_on_os_type(paths: list) -> str:
-    import matlab_proxy.util.system as system
-
-    return "\\".join(paths) if system.is_windows() else "/".join(paths)
-
-
-# Test for is_download_request function
-@pytest.mark.parametrize(
-    "test_base_url, path, expected",
-    [
-        ("/", "/download/something", True),
-        ("", "/download/something", True),
-        ("/base", "/base/download/something", True),
-        ("/base", "/download/something", False),
-    ],
-    ids=[
-        "/ base url and path starting with /download",
-        "empty base url and path starting with /download",
-        "non-empty base url and path starting with that base url",
-        "non-empty base url and path not starting with that base url",
-    ],
-)
-def test_is_download_request(mock_request_fixture, test_base_url, path, expected):
-    mock_request_fixture.app["settings"]["base_url"] = test_base_url
-    mock_request_fixture.rel_url.path = path
-    assert is_download_request(mock_request_fixture) == expected
-
-
-# Test for _get_download_payload_path function
-# This test is a bit tricky since it involves file system operations and OS checks.
-# We will mock system.is_windows() and test for both Windows and Posix systems.
-@pytest.mark.parametrize(
-    "is_windows, test_base_url, path, expected",
-    [
-        (
-            True,
-            "",
-            "/downloadC:\\some\\path\\to\\file.txt",
-            "C:\\some\\path\\to\\file.txt",
-        ),
-        (
-            True,
-            "/base",
-            "/base/downloadC:\\some\\path\\to\\file.txt",
-            "C:\\some\\path\\to\\file.txt",
-        ),
-        (
-            False,
-            "",
-            "/download/some/path/to/file.txt",
-            _get_expected_output_based_on_os_type(["/some", "path", "to", "file.txt"]),
-        ),
-        (
-            False,
-            "/base",
-            "/base/download/some/path/to/file.txt",
-            _get_expected_output_based_on_os_type(["/some", "path", "to", "file.txt"]),
-        ),
-    ],
-    ids=[
-        "Windows with null base url",
-        "Windows with non-null base url",
-        "Linux with null base url",
-        "Linux with non-null base url",
-    ],
-)
-def test_get_download_payload_path(
-    mock_request_fixture, mocker, is_windows, test_base_url, path, expected
-):
-    mocker.patch("matlab_proxy.util.system.is_windows", return_value=is_windows)
-    mock_request_fixture.app["settings"]["base_url"] = test_base_url
-    mock_request_fixture.rel_url.path = path
-    assert _get_download_payload_path(mock_request_fixture) == expected
-
-
-def test_get_download_payload_path_invalid_request(mock_request_fixture):
-    test_base_url = "/base"
-    path = "/download/something"
-
-    mock_request_fixture.app["settings"]["base_url"] = test_base_url
-    mock_request_fixture.rel_url.path = path
-
-    assert _get_download_payload_path(mock_request_fixture) is None
-
-
-@pytest.mark.parametrize(
-    "response_json, expected_url",
-    [
-        (
-            {
-                "messages": {
-                    "FEvalResponse": [
-                        {"isError": False, "results": ["http://download-url.com"]}
-                    ]
-                }
-            },
-            "http://download-url.com",
-        ),
-        ({"messages": {"FEvalResponse": [{"isError": True}]}}, None),
-    ],
-    ids=["connector returning correct download url", "connector returning an error"],
-)
-async def test_get_download_url(
-    mock_request_fixture, mocker, response_json, expected_url
-):
-    test_base_url = "/"
-    path = "/download/some/path/to/file.txt"
-
-    mock_request_fixture.app["state"].settings = {
-        "mwi_server_url": "http://mwi-server.com"
-    }
-    mock_request_fixture.app["settings"]["base_url"] = test_base_url
-    mock_request_fixture.rel_url.path = path
-
-    mocker.patch(
-        "matlab_proxy.util.mwi.embedded_connector.helpers.get_data_to_feval_mcode",
-        return_value={},
-    )
-    mocker.patch(
-        "matlab_proxy.util.mwi.embedded_connector.helpers.get_mvm_endpoint",
-        return_value="http://mwi-server.com",
-    )
-    mocker.patch(
-        "matlab_proxy.util.mwi.embedded_connector.send_request",
-        return_value=response_json,
-    )
-
-    download_url = await get_download_url(mock_request_fixture)
-
-    assert download_url == expected_url

tests/unit/util/mwi/test_logger.py

@@ -1,82 +0,0 @@
-# Copyright 2020-2024 The MathWorks, Inc.
-"""This file tests methods present in matlab_proxy/util/mwi_logger.py"""
-
-import logging
-import os
-import pytest
-from matlab_proxy.util.mwi import logger as mwi_logger
-
-
-def test_get():
-    """This test checks if the get method returns a logger with expected name"""
-    logger = mwi_logger.get()
-    # Okay to use hidden API for testing only.
-    assert logger.name == mwi_logger.__get_mw_logger_name()
-
-
-def test_get_mw_logger_name():
-    """Test to lock down the name of the logger used."""
-    # Okay to use hidden API for testing only.
-    assert "MATLABProxyApp" == mwi_logger.__get_mw_logger_name()
-
-
-def test_get_with_no_environment_variables(monkeypatch):
-    """This test checks if the get method returns a logger with default settings if no environment variable is set"""
-    # Delete the environment variables if they do exist
-    env_names_list = mwi_logger.get_environment_variable_names()
-    monkeypatch.delenv(env_names_list[0], raising=False)
-    monkeypatch.delenv(env_names_list[1], raising=False)
-
-    logger = mwi_logger.get(init=True)
-    assert logger.isEnabledFor(logging.INFO) == True
-    assert len(logger.handlers) == 0
-
-
-def test_get_with_environment_variables(monkeypatch, tmp_path):
-    """This test checks if the get method returns a logger with the specified settings"""
-    env_names_list = mwi_logger.get_environment_variable_names()
-    monkeypatch.setenv(env_names_list[0], "CRITICAL")
-    monkeypatch.setenv(env_names_list[1], str(tmp_path / "testing123.log"))
-
-    logger = mwi_logger.get(init=True)
-
-    # Verify that environment variable controlling level is respected
-    assert logger.isEnabledFor(logging.CRITICAL) == True
-
-    # Verify that environment variable setting the file is respected
-    assert len(logger.handlers) == 1
-    assert os.path.basename(logger.handlers[0].baseFilename) == "testing123.log"
-
-
-@pytest.mark.parametrize(
-    "log_level, expected_level",
-    [
-        ("DEBUG", logging.DEBUG),
-        ("INFO", logging.INFO),
-        ("WARNING", logging.WARNING),
-        ("debug", logging.DEBUG),
-        ("info", logging.INFO),
-        ("warning", logging.WARNING),
-    ],
-)
-def test_set_logging_configuration_known_logging_levels(
-    monkeypatch, log_level, expected_level
-):
-    """This test checks if the logger is set with correct level for known log levels"""
-    env_names_list = mwi_logger.get_environment_variable_names()
-    monkeypatch.setenv(env_names_list[0], log_level)
-    logger = mwi_logger.get(init=True)
-    assert (
-        logger.isEnabledFor(expected_level) == True
-    ), f"Error in initialising the logger with {log_level}"
-
-
-@pytest.mark.parametrize("log_level", ["ABC", "abc"])
-def test_set_logging_configuration_unknown_logging_levels(monkeypatch, log_level):
-    """This test checks if the logger is set with INFO level for unknown log levels"""
-    env_names_list = mwi_logger.get_environment_variable_names()
-    monkeypatch.setenv(env_names_list[0], log_level)
-    logger = mwi_logger.get(init=True)
-    assert (
-        logger.isEnabledFor(logging.INFO) == True
-    ), "Error in initialising the default logger"