matlab-proxy 0.15.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

tests/unit/util/mwi/test_custom_http_headers.py

@@ -0,0 +1,281 @@
+# 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_logger.py

@@ -0,0 +1,49 @@
+# Copyright 2020-2022 The MathWorks, Inc.
+"""This file tests methods present in matlab_proxy/util/mwi_logger.py
+"""
+
+import logging
+import os
+
+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"""
+    # 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 default 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"

tests/unit/util/mwi/test_token_auth.py

@@ -0,0 +1,303 @@
+# Copyright 2023-2024 The MathWorks, Inc.
+
+import pytest
+from aiohttp import web
+from aiohttp_session import setup as aiohttp_session_setup
+from aiohttp_session.cookie_storage import EncryptedCookieStorage
+from cryptography import fernet
+
+from matlab_proxy.constants import MWI_AUTH_TOKEN_NAME_FOR_HTTP
+from matlab_proxy.util.mwi import environment_variables as mwi_env
+from matlab_proxy.util.mwi import token_auth
+
+## APIs to test:
+# 1. generate_mwi_auth_token (auth enabled, auth enabled+custom token, custom token, auth disabled)
+# 2. authenticate_access_decorator (headers & url_string, and session storage)
+
+## Testing generate_mwi_auth_token :
+
+test_data = [
+    pytest.param(
+        "False",
+        "CustomTokenStr123_-Test1",
+        None,
+        id="token isn't generated when MWI_ENABLE_AUTH_TOKEN is explicitly disabled & has custom token set",
+    ),
+    pytest.param(
+        "",
+        "CustomTokenStr123_-Test2",
+        "CustomTokenStr123_-Test2",
+        id="token is generated when MWI_ENABLE_AUTH_TOKEN is not set & has custom token set",
+    ),
+    pytest.param(
+        "True",
+        "CustomTokenStr123_-Test3",
+        "CustomTokenStr123_-Test3",
+        id="token is generated when MWI_ENABLE_AUTH_TOKEN is set & has custom token set",
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "expected_auth_enablement, auth_token, expected_auth_token",
+    test_data,
+)
+def test_generate_mwi_auth_token(
+    monkeypatch, expected_auth_enablement, auth_token, expected_auth_token
+):
+    monkeypatch.setenv(
+        mwi_env.get_env_name_enable_mwi_auth_token(), str(expected_auth_enablement)
+    )
+    monkeypatch.setenv(mwi_env.get_env_name_mwi_auth_token(), str(auth_token))
+
+    generated_token = token_auth.generate_mwi_auth_token_and_hash()["token"]
+    assert generated_token == expected_auth_token
+
+
+def test_auto_token_generation_with_enable_flag_set(monkeypatch):
+    # Test if token is auto-generated when MWI_ENABLE_AUTH_TOKEN is True
+    expected_auth_enablement = "True"
+    monkeypatch.setenv(
+        mwi_env.get_env_name_enable_mwi_auth_token(), str(expected_auth_enablement)
+    )
+
+    generated_token = token_auth.generate_mwi_auth_token_and_hash()["token"]
+    assert generated_token is not None
+
+
+def test_auto_token_generation_with_enable_flag_unset():
+    # Test if token is generated by default when MWI_ENABLE_AUTH_TOKEN and MWI_AUTH_TOKEN are not set
+    generated_token = token_auth.generate_mwi_auth_token_and_hash()["token"]
+    assert generated_token is not None
+
+
+## Testing authenticate_access_decorator :
+# This in turn, also tests authenticate_request
+
+
+@pytest.fixture
+def get_custom_auth_token_str():
+    return "CustomTokenStr123_-TestOtherAPIS"
+
+
+@token_auth.authenticate_access_decorator
+async def fake_endpoint(request):
+    if request.method == "POST":
+        request.app["value"] = (await request.post())["value"]
+        return web.Response(body=b"thanks for the data")
+    return web.Response(body="value: {}".format(request.app["value"]).encode("utf-8"))
+
+
+@pytest.fixture
+def fake_server_with_auth_enabled(
+    loop, aiohttp_client, monkeypatch, get_custom_auth_token_str
+):
+    auth_token = get_custom_auth_token_str
+    auth_enablement = "True"
+    monkeypatch.setenv(
+        mwi_env.get_env_name_enable_mwi_auth_token(), str(auth_enablement)
+    )
+    monkeypatch.setenv(mwi_env.get_env_name_mwi_auth_token(), str(auth_token))
+
+    (
+        mwi_auth_token,
+        mwi_auth_token_hash,
+    ) = token_auth.generate_mwi_auth_token_and_hash().values()
+
+    app = web.Application()
+    app["settings"] = {
+        "mwi_is_token_auth_enabled": mwi_auth_token is not None,
+        "mwi_auth_token": mwi_auth_token,
+        "mwi_auth_token_hash": mwi_auth_token_hash,
+        "mwi_auth_token_name_for_http": MWI_AUTH_TOKEN_NAME_FOR_HTTP,
+        "mwi_auth_token_name_for_env": mwi_env.get_env_name_mwi_auth_token().lower(),
+    }
+    app.router.add_get("/", fake_endpoint)
+    app.router.add_post("/", fake_endpoint)
+    # Setup the session storage
+    fernet_key = fernet.Fernet.generate_key()
+    f = fernet.Fernet(fernet_key)
+    aiohttp_session_setup(
+        app, EncryptedCookieStorage(f, cookie_name="matlab-proxy-session")
+    )
+    return loop.run_until_complete(aiohttp_client(app))
+
+
+async def test_set_value_with_token(
+    fake_server_with_auth_enabled, get_custom_auth_token_str
+):
+    resp = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foo"},
+        headers={MWI_AUTH_TOKEN_NAME_FOR_HTTP: get_custom_auth_token_str},
+    )
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "thanks for the data"
+    assert fake_server_with_auth_enabled.server.app["value"] == "foo"
+
+    # Test subsequent requests do not need token authentication
+    resp2 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar"},
+    )
+    assert resp2.status == web.HTTPOk.status_code
+    assert fake_server_with_auth_enabled.server.app["value"] == "foobar"
+
+    # Test request which accepts cookies from previous request
+    resp3 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar1"},
+        cookies=resp.cookies,
+    )
+    assert resp3.status == web.HTTPOk.status_code
+    assert fake_server_with_auth_enabled.server.app["value"] == "foobar1"
+
+
+async def test_set_value_with_token_hash(
+    fake_server_with_auth_enabled, get_custom_auth_token_str
+):
+    resp = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foo"},
+        headers={
+            MWI_AUTH_TOKEN_NAME_FOR_HTTP: token_auth._generate_hash(
+                get_custom_auth_token_str
+            )
+        },
+    )
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "thanks for the data"
+    assert fake_server_with_auth_enabled.server.app["value"] == "foo"
+
+    # Test subsequent requests do not need token authentication
+    resp2 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar"},
+    )
+    assert resp2.status == web.HTTPOk.status_code
+    assert fake_server_with_auth_enabled.server.app["value"] == "foobar"
+
+    # Test request which accepts cookies from previous request
+    resp3 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar1"},
+        cookies=resp.cookies,
+    )
+    assert resp3.status == web.HTTPOk.status_code
+    assert fake_server_with_auth_enabled.server.app["value"] == "foobar1"
+
+
+async def test_set_value_without_token(fake_server_with_auth_enabled):
+    resp2 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar"},
+    )
+    assert resp2.status == web.HTTPForbidden.status_code
+
+
+async def test_set_value_with_invalid_token(fake_server_with_auth_enabled):
+    resp2 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar"},
+        headers={MWI_AUTH_TOKEN_NAME_FOR_HTTP: "invalid-token"},
+    )
+    assert resp2.status == web.HTTPForbidden.status_code
+
+
+async def test_set_value_with_token_in_params(
+    fake_server_with_auth_enabled, get_custom_auth_token_str
+):
+    fake_server_with_auth_enabled.server.app["value"] = "foo"
+    resp = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foofoo"},
+        params={
+            MWI_AUTH_TOKEN_NAME_FOR_HTTP: token_auth._generate_hash(
+                get_custom_auth_token_str
+            )
+        },
+    )
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "thanks for the data"
+    assert fake_server_with_auth_enabled.server.app["value"] == "foofoo"
+
+    # Test subsequent requests do not need token authentication
+    resp2 = await fake_server_with_auth_enabled.post(
+        "/",
+        data={"value": "foobar"},
+    )
+    assert resp2.status == web.HTTPForbidden.status_code
+    # assert server_with_auth_enabled.server.app["value"] == "foobar"
+
+
+async def test_get_value_without_token(fake_server_with_auth_enabled):
+    fake_server_with_auth_enabled.server.app["value"] = "bar"
+    resp = await fake_server_with_auth_enabled.get("/")
+    assert resp.status == web.HTTPForbidden.status_code
+
+
+async def test_get_value_with_token_in_query_params(
+    fake_server_with_auth_enabled, get_custom_auth_token_str
+):
+    fake_server_with_auth_enabled.server.app["value"] = "bar"
+    resp = await fake_server_with_auth_enabled.get(
+        "/",
+        params={
+            MWI_AUTH_TOKEN_NAME_FOR_HTTP: token_auth._generate_hash(
+                get_custom_auth_token_str
+            )
+        },
+    )
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "value: bar"
+
+
+## Create a fake_server without authentication enabled, and test that you can access data.
+
+
+@pytest.fixture
+def fake_server_without_auth_enabled(loop, aiohttp_client, monkeypatch):
+    auth_enablement = "False"
+    monkeypatch.setenv(
+        mwi_env.get_env_name_enable_mwi_auth_token(), str(auth_enablement)
+    )
+    (
+        mwi_auth_token,
+        mwi_auth_token_hash,
+    ) = token_auth.generate_mwi_auth_token_and_hash().values()
+
+    app = web.Application()
+    app["settings"] = {
+        "mwi_is_token_auth_enabled": mwi_auth_token != None,
+        "mwi_auth_token": mwi_auth_token,
+        "mwi_auth_token_hash": mwi_auth_token_hash,
+        "mwi_auth_token_name_for_env": mwi_env.get_env_name_mwi_auth_token().lower(),
+    }
+    app.router.add_get("/", fake_endpoint)
+    app.router.add_post("/", fake_endpoint)
+    # Setup the session storage
+    fernet_key = fernet.Fernet.generate_key()
+    f = fernet.Fernet(fernet_key)
+    aiohttp_session_setup(
+        app, EncryptedCookieStorage(f, cookie_name="matlab-proxy-session")
+    )
+    return loop.run_until_complete(aiohttp_client(app))
+
+
+async def test_get_value(fake_server_without_auth_enabled):
+    fake_server_without_auth_enabled.server.app["value"] = "bar1"
+    resp = await fake_server_without_auth_enabled.get("/")
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "value: bar1"
+
+
+async def test_get_value_in_query_params(
+    fake_server_without_auth_enabled, get_custom_auth_token_str
+):
+    # Server should respond even if token is provided when not needed.
+    fake_server_without_auth_enabled.server.app["value"] = "bar2"
+    resp = await fake_server_without_auth_enabled.get(
+        "/", params={"mwi-auth-token": get_custom_auth_token_str}
+    )
+    assert resp.status == web.HTTPOk.status_code
+    assert await resp.text() == "value: bar2"