Removed unused parameters from test_app_state.py::test_is_licensed

Author: diningPhilosopher64

tests/unit/test_app_state.py

@@ -14,13 +14,27 @@
 
 @pytest.fixture
 def app_state_fixture():
+    """A pytest fixture which returns an instance of AppState class with no errors.
+
+    Returns:
+        AppState: An object of the AppState class
+    """
     settings = {"error": None}
     app_state = AppState(settings=settings)
     return app_state
 
 
 @pytest.fixture
 def mocker_os_patching_fixture(mocker, platform):
+    """A pytest fixture which patches the is_* functions in system.py module
+
+    Args:
+        mocker : Built in pytest fixture
+        platform (str): A string representing "windows", "linux" or "mac"
+
+    Returns:
+        mocker: Built in pytest fixture with patched calls to system.py module.
+    """
     mocker.patch("matlab_proxy.app_state.system.is_linux", return_value=False)
     mocker.patch("matlab_proxy.app_state.system.is_windows", return_value=False)
     mocker.patch("matlab_proxy.app_state.system.is_mac", return_value=False)
@@ -35,11 +49,15 @@ def mocker_os_patching_fixture(mocker, platform):
 
 @dataclass(frozen=True)
 class Mock_xvfb:
+    """An immutable dataclass representing a mocked Xvfb process"""
+
     returncode: Optional[int]
 
 
 @dataclass(frozen=True)
 class Mock_matlab:
+    """An immutable dataclass representing a mocked MATLAB process"""
+
     returncode: Optional[int]
 
 
@@ -74,32 +92,67 @@ class Mock_matlab:
     ],
 )
 def test_is_licensed(app_state_fixture, licensing, expected):
+    """Test to check is_licensed()
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+        licensing (dict): Represents licensing information
+        expected (bool): Expected return value.
+    """
+    # Arrange
+    # Nothing to arrange
+
+    # Act
     app_state_fixture.licensing = licensing
+
+    # Assert
     assert app_state_fixture.is_licensed() == expected
 
 
 @pytest.mark.parametrize(
-    "err, licensing, expected_err",
+    "err, expected_err",
     [
-        (MatlabError(message="dummy error"), None, MatlabError(message="dummy")),
-        (LicensingError(message="license issue"), None, None),
+        (MatlabError(message="dummy error"), MatlabError(message="dummy")),
+        (LicensingError(message="license issue"), None),
     ],
     ids=["Any error except licensing error", "licensing error"],
 )
-def test_unset_licensing(err, licensing, expected_err):
+def test_unset_licensing(err, expected_err):
+    """Test to check unset_liecnsing removes licensing from the AppState object
+
+    Args:
+        err (Exception): Custom exceptions defined in exceptions.py
+        licensing (bool): Whether licensing info is removed
+        expected_err (Exception): Expected exception
+    """
+    # Arrange
     settings = {"error": err}
     app_state = AppState(settings=settings)
+
+    # Act
     app_state.unset_licensing()
-    assert app_state.licensing == licensing
+
+    # Assert
+    assert app_state.licensing == None
     assert type(app_state.error) is type(expected_err)
 
 
 # config file is deleted when licensing info is not set i.e. set to None
 def test_persist_licensing_when_licensing_info_is_not_set(tmp_path):
+    """Test to check if data is not persisted to a file if licensing info is not present
+
+    Args:
+        tmp_path (Path): Built in pytest fixture
+    """
+    # Arrange
     tmp_file = tmp_path / "tmp_file.json"
     settings = {"matlab_config_file": tmp_file, "error": None}
     app_state = AppState(settings=settings)
+
+    # Act
     app_state.persist_licensing()
+
+    # Assert
     assert os.path.exists(tmp_file) is False
 
 
@@ -121,13 +174,24 @@ def test_persist_licensing_when_licensing_info_is_not_set(tmp_path):
     ids=["nlm type", "mhlm type", "existing license type"],
 )
 def test_persist_licensing(data: dict, tmp_path):
+    """Test to check if persist_licensing() writes data to the file system
+
+    Args:
+        data (dict): Represents matlab-proxy licensing data
+        tmp_path : Built-in pytest fixture.
+    """
+    # Arrange
     tmp_file = tmp_path / "parent_1" / "parent_2" / "tmp_file.json"
     settings = {"matlab_config_file": tmp_file, "error": None}
     app_state = AppState(settings=settings)
     app_state.licensing = data
+
+    # Act
     app_state.persist_licensing()
     with open(tmp_file, "r") as file:
         got = file.read()
+
+    # Assert
     assert json.loads(got) == data
 
 
@@ -169,7 +233,23 @@ def test_persist_licensing(data: dict, tmp_path):
 def test_are_required_processes_ready(
     app_state_fixture, mocker_os_patching_fixture, matlab, xvfb, expected
 ):
-    assert app_state_fixture._are_required_processes_ready(matlab, xvfb) == expected
+    """Test to check if required processes are ready
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+        mocker_os_patching_fixture (mocker): Custom pytest fixture for mocking
+        matlab (Mock_matlab): Represents a mocked MATLAB process
+        xvfb (Mock_xvfb): Represents a mocked Xvfb process
+        expected (bool): Expected return value based on process return code
+    """
+    # Arrange
+    # Nothing to arrange
+
+    # Act
+    actual = app_state_fixture._are_required_processes_ready(matlab, xvfb)
+
+    # Assert
+    assert actual == expected
 
 
 get_matlab_status_based_on_connector_status_test_data = [
@@ -187,6 +267,15 @@ def test_are_required_processes_ready(
 async def test_get_matlab_status_based_on_connector_status(
     mocker, connector_status, ready_file_present, matlab_status
 ):
+    """Test to check matlab status based on connector status
+
+    Args:
+        mocker : Built in pytest fixture.
+        connector_status (str): Status of Embedded Connector.
+        ready_file_present (bool): Represents if the ready file has been created or not.
+        matlab_status (str): Represents the status of MATLAB process.
+    """
+    # Arrange
     mocker.patch(
         "matlab_proxy.app_state.mwi.embedded_connector.request.get_state",
         return_value=connector_status,
@@ -199,7 +288,12 @@ async def test_get_matlab_status_based_on_connector_status(
     }
     app_state = AppState(settings=settings)
     app_state.matlab_session_files["matlab_ready_file"] = Path("dummy")
-    assert await app_state._get_matlab_connector_status() == matlab_status
+
+    # Act
+    actual_matlab_status = await app_state._get_matlab_connector_status()
+
+    # Assert
+    assert actual_matlab_status == matlab_status
 
 
 @pytest.mark.parametrize(
@@ -218,6 +312,16 @@ async def test_get_matlab_status_based_on_connector_status(
 async def test_get_matlab_state(
     app_state_fixture, mocker, valid_processes, connector_status, expected
 ):
+    """Test to check get_matlab_state returns the correct MATLAB state based on the connector status
+
+    Args:
+        app_state_fixture (AppState): Object of AppState class with defaults set
+        mocker : Built in pytest fixture
+        valid_processes (bool): Represents if the processes are valid or not
+        connector_status (str): Status of Embedded Connector.
+        expected (str): Expected status of MATLAB process.
+    """
+    # Arrange
     mocker.patch.object(
         AppState,
         "_are_required_processes_ready",
@@ -228,11 +332,24 @@ async def test_get_matlab_state(
         "_get_matlab_connector_status",
         return_value=connector_status,
     )
-    assert await app_state_fixture.get_matlab_state() == expected
+
+    # Act
+    actual_state = await app_state_fixture.get_matlab_state()
+
+    # Assert
+    assert actual_state == expected
 
 
 @pytest.mark.parametrize("platform", [("linux"), ("windows"), ("mac")])
 async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fixture):
+    """Test to check track_embedded_connector task
+
+    Args:
+        mocker_os_patching_fixture (mocker): Custom pytest fixture for mocking
+        app_state_fixture (AppState): Object of AppState class with defaults set
+    """
+
+    # Arrange
     # patching embedded_connector_start_time to EPOCH+1 seconds and state to be "down"
     mocker_os_patching_fixture.patch.object(
         app_state_fixture, "embedded_connector_start_time", new=float(1.0)
@@ -243,7 +360,11 @@ async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fi
 
     # verify that stop_matlab() is called once
     spy = mocker_os_patching_fixture.spy(app_state_fixture, "stop_matlab")
+
+    # Act
     await app_state_fixture._AppState__track_embedded_connector_state()
+
+    # Assert
     spy.assert_called_once()
 
 
@@ -255,10 +376,22 @@ async def test_track_embedded_connector(mocker_os_patching_fixture, app_state_fi
 def test_env_variables_filtration_for_xvfb_process(
     monkeypatch, env_var_name, filter_prefix, is_filtered
 ):
+    """Test to check if __filter_env_variables filters environment variables with a certain prefix correctly.
+
+    Args:
+        monkeypatch (Object): Built-in pytest fixture for monkeypatching
+        env_var_name (str): Name of the environment variable
+        filter_prefix (str): Prefix to check for filtering
+        is_filtered (bool): To check if the env variable with specified prefix is filtered.
+    """
+    # Arrange
     env_var = env_var_name
     monkeypatch.setenv(env_var, "foo")
 
+    # Act
     filtered_env_vars: dict = AppState._AppState__filter_env_variables(
         os.environ, filter_prefix
     )
+
+    # Assert
     assert filtered_env_vars.get(env_var) == is_filtered