467 get 100 coverage on backend and utils (#468)

* Test converters

* Test preamble and update check

* Use parametrize on exception

* Test get bindings

* Get binding instance

* Apply static analysis

* Utils covered

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fixed error message usage

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: kjy5

.idea/ephys-link.iml

@@ -20,7 +20,7 @@
 from vbl_aquarium.models.ephys_link import EphysLinkOptions
 
 from ephys_link.__about__ import __version__ as version
-from ephys_link.utils.startup import get_binding_display_to_cli_name
+from ephys_link.utils.startup import get_bindings
 
 # Define options path.
 OPTIONS_DIR = join(user_config_dir(), "VBL", "Ephys Link")
@@ -156,7 +156,7 @@ def _build_gui(self) -> None:
         platform_type_settings = ttk.LabelFrame(mainframe, text="Platform Type", padding=3)
         platform_type_settings.grid(column=0, row=1, sticky="news")
 
-        for index, (display_name, cli_name) in enumerate(get_binding_display_to_cli_name().items()):
+        for index, (display_name, cli_name) in enumerate(self._get_binding_display_to_cli_name().items()):
             ttk.Radiobutton(
                 platform_type_settings,
                 text=display_name,
@@ -202,3 +202,11 @@ def _launch_server(self) -> None:
         """
         self._submit = True
         self._root.destroy()
+
+    def _get_binding_display_to_cli_name(self) -> dict[str, str]:
+        """Get mapping of display to CLI option names of the available platform bindings.
+
+        Returns:
+            Dictionary of platform binding display name to CLI option name.
+        """
+        return {binding_type.get_display_name(): binding_type.get_cli_name() for binding_type in get_bindings()}

.idea/misc.xml

@@ -86,3 +86,21 @@ def client_disconnected_without_being_connected_error(client_sid: str) -> str:
 
 MALFORMED_REQUEST_ERROR = {"error": "Malformed request."}
 UNKNOWN_EVENT_ERROR = {"error": "Unknown event."}
+
+UNABLE_TO_CHECK_FOR_UPDATES_ERROR = (
+    "Unable to check for updates. Ignore updates or use the -i flag to disable checks.\n"
+)
+
+
+def ump_4_3_deprecation_error(cli_name: str):
+    return f"CLI option '{cli_name}' is deprecated and will be removed in v3.0.0. Use 'ump' instead."
+
+
+def unrecognized_platform_type_error(cli_name: str) -> str:
+    """Generate an error message for when the platform type is not recognized.
+    Args:
+        cli_name: The platform type that is not recognized.
+    Returns:
+        str: The error message.
+    """
+    return f'Platform type "{cli_name}" not recognized.'

src/ephys_link/front_end/gui.py

@@ -12,7 +12,13 @@
 from ephys_link.bindings.mpm_binding import MPMBinding
 from ephys_link.front_end.console import Console
 from ephys_link.utils.base_binding import BaseBinding
-from ephys_link.utils.constants import ASCII, BINDINGS_DIRECTORY
+from ephys_link.utils.constants import (
+    ASCII,
+    BINDINGS_DIRECTORY,
+    UNABLE_TO_CHECK_FOR_UPDATES_ERROR,
+    ump_4_3_deprecation_error,
+    unrecognized_platform_type_error,
+)
 
 
 def preamble() -> None:
@@ -39,9 +45,7 @@ def check_for_updates(console: Console) -> None:
             console.critical_print(f"Update available: {latest_version} (current: {__version__})")
             console.critical_print("Download at: https://github.com/VirtualBrainLab/ephys-link/releases/latest")
     except (ConnectionError, ConnectTimeout):
-        console.error_print(
-            "UPDATE", "Unable to check for updates. Ignore updates or use the the -i flag to disable checks.\n"
-        )
+        console.error_print("UPDATE", UNABLE_TO_CHECK_FOR_UPDATES_ERROR)
 
 
 def get_bindings() -> list[type[BaseBinding]]:
@@ -80,7 +84,7 @@ def get_binding_instance(options: EphysLinkOptions, console: Console) -> BaseBin
         if selected_type in ("ump-4", "ump-3"):
             console.error_print(
                 "DEPRECATION",
-                f"CLI option '{selected_type}' is deprecated and will be removed in v3.0.0. Use 'ump' instead.",
+                ump_4_3_deprecation_error(selected_type),
             )
             selected_type = "ump"
 
@@ -93,15 +97,6 @@ def get_binding_instance(options: EphysLinkOptions, console: Console) -> BaseBin
             return binding_type()
 
     # Raise an error if the platform type is not recognized.
-    error_message = f'Platform type "{options.type}" not recognized.'
+    error_message = unrecognized_platform_type_error(selected_type)
     console.critical_print(error_message)
     raise ValueError(error_message)
-
-
-def get_binding_display_to_cli_name() -> dict[str, str]:
-    """Get mapping of display to CLI option names of the available platform bindings.
-
-    Returns:
-        Dictionary of platform binding display name to CLI option name.
-    """
-    return {binding_type.get_display_name(): binding_type.get_cli_name() for binding_type in get_bindings()}

src/ephys_link/utils/constants.py

@@ -0,0 +1,136 @@
+"""Unit tests for converters.py with 100% coverage."""
+
+from vbl_aquarium.models.unity import Vector4
+
+from ephys_link.utils.converters import list_to_vector4, scalar_mm_to_um, um_to_mm, vector4_to_array, vector_mm_to_um
+from tests.conftest import DUMMY_VECTOR4
+
+
+class TestConverters:
+    """Test class for converters module with 100% coverage."""
+
+    def test_scalar_mm_to_um_positive(self):
+        """Test scalar mm to um conversion with positive value."""
+        result = scalar_mm_to_um(5.5)
+        assert result == 5500.0
+
+    def test_scalar_mm_to_um_negative(self):
+        """Test scalar mm to um conversion with negative value."""
+        result = scalar_mm_to_um(-2.3)
+        assert result == -2300.0
+
+    def test_scalar_mm_to_um_zero(self):
+        """Test scalar mm to um conversion with zero."""
+        result = scalar_mm_to_um(0.0)
+        assert result == 0.0
+
+    def test_vector_mm_to_um(self):
+        """Test vector mm to um conversion using dummy vector."""
+        # DUMMY_VECTOR4 is Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+        result = vector_mm_to_um(DUMMY_VECTOR4)
+        expected = Vector4(x=1000.0, y=2000.0, z=3000.0, w=4000.0)
+
+        assert result == expected
+
+    def test_vector_mm_to_um_with_zeros(self):
+        """Test vector mm to um conversion with zero values."""
+        input_vector = Vector4(x=0.0, y=5.0, z=0.0, w=-1.0)
+        result = vector_mm_to_um(input_vector)
+        expected = Vector4(x=0.0, y=5000.0, z=0.0, w=-1000.0)
+
+        assert result == expected
+
+    def test_um_to_mm(self):
+        """Test um to mm conversion."""
+        input_vector = Vector4(x=1000.0, y=2000.0, z=3000.0, w=4000.0)
+        result = um_to_mm(input_vector)
+        expected = Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+
+        assert result == expected
+
+    def test_um_to_mm_with_decimals(self):
+        """Test um to mm conversion with decimal results."""
+        input_vector = Vector4(x=500.0, y=1500.0, z=2500.0, w=3500.0)
+        result = um_to_mm(input_vector)
+        expected = Vector4(x=0.5, y=1.5, z=2.5, w=3.5)
+
+        assert result == expected
+
+    def test_vector4_to_array(self):
+        """Test Vector4 to array conversion using dummy vector."""
+        # DUMMY_VECTOR4 is Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+        result = vector4_to_array(DUMMY_VECTOR4)
+
+        assert result == [1.0, 2.0, 3.0, 4.0]
+        assert isinstance(result, list)
+        assert all(isinstance(x, float) for x in result)
+
+    def test_vector4_to_array_with_negative_values(self):
+        """Test Vector4 to array conversion with negative values."""
+        input_vector = Vector4(x=-1.0, y=0.0, z=5.0, w=-10.0)
+        result = vector4_to_array(input_vector)
+
+        assert result == [-1.0, 0.0, 5.0, -10.0]
+
+    def test_list_to_vector4_exact_four_elements(self):
+        """Test list to Vector4 conversion with exactly 4 elements."""
+        float_list = [1.0, 2.0, 3.0, 4.0]
+        result = list_to_vector4(float_list)
+        expected = Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+
+        assert result == expected
+
+    def test_list_to_vector4_less_than_four_elements(self):
+        """Test list to Vector4 conversion with less than 4 elements (padding with zeros)."""
+        # Test with 3 elements
+        float_list = [1.0, 2.0, 3.0]
+        result = list_to_vector4(float_list)
+        assert result == Vector4(x=1.0, y=2.0, z=3.0, w=0.0)
+
+        # Test with 2 elements
+        float_list = [5.0, 6.0]
+        result = list_to_vector4(float_list)
+        assert result == Vector4(x=5.0, y=6.0, z=0.0, w=0.0)
+
+        # Test with 1 element
+        float_list = [7.0]
+        result = list_to_vector4(float_list)
+        assert result == Vector4(x=7.0, y=0.0, z=0.0, w=0.0)
+
+    def test_list_to_vector4_empty_list(self):
+        """Test list to Vector4 conversion with empty list (all zeros)."""
+        float_list: list[float] = []
+        result = list_to_vector4(float_list)
+        expected = Vector4(x=0.0, y=0.0, z=0.0, w=0.0)
+
+        assert result == expected
+
+    def test_list_to_vector4_more_than_four_elements(self):
+        """Test list to Vector4 conversion with more than 4 elements (ignores extra)."""
+        float_list = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
+        result = list_to_vector4(float_list)
+        expected = Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+
+        assert result == expected
+
+    def test_list_to_vector4_with_integers(self):
+        """Test list to Vector4 conversion with integer inputs."""
+        int_list = [1, 2, 3, 4]
+        result = list_to_vector4(int_list)  # pyright: ignore[reportArgumentType]
+        expected = Vector4(x=1.0, y=2.0, z=3.0, w=4.0)
+
+        assert result == expected
+
+        # Verify they're floats in the Vector4
+        assert isinstance(result.x, float)
+        assert isinstance(result.y, float)
+        assert isinstance(result.z, float)
+        assert isinstance(result.w, float)
+
+    def test_list_to_vector4_mixed_types(self):
+        """Test list to Vector4 conversion with mixed int and float types."""
+        mixed_list = [1, 2.5, 3, 4.5]
+        result = list_to_vector4(mixed_list)
+        expected = Vector4(x=1.0, y=2.5, z=3.0, w=4.5)
+
+        assert result == expected

src/ephys_link/utils/startup.py

@@ -0,0 +1,137 @@
+import sys
+from io import StringIO
+
+import pytest
+from pytest_mock import MockerFixture
+from requests import ConnectionError, ConnectTimeout
+from vbl_aquarium.models.ephys_link import EphysLinkOptions
+
+from ephys_link.__about__ import __version__
+from ephys_link.bindings.fake_binding import FakeBinding
+from ephys_link.bindings.mpm_binding import MPMBinding
+from ephys_link.front_end.console import Console
+from ephys_link.utils.base_binding import BaseBinding
+from ephys_link.utils.constants import (
+    ASCII,
+    UNABLE_TO_CHECK_FOR_UPDATES_ERROR,
+    ump_4_3_deprecation_error,
+    unrecognized_platform_type_error,
+)
+from ephys_link.utils.startup import check_for_updates, get_binding_instance, get_bindings, preamble
+
+
+class TestStartup:
+    @pytest.fixture
+    def console(self, mocker: MockerFixture) -> Console:
+        """Fixture for mock console."""
+        return mocker.Mock(spec=Console)
+
+    def test_preamble(self) -> None:
+        """Test the preamble function."""
+        # Arrange.
+        captured_output = StringIO()
+        sys.stdout = captured_output
+
+        # Act.
+        preamble()
+
+        # Assert.
+        sys.stdout = sys.__stdout__
+        output = captured_output.getvalue()
+
+        assert "Ephys Link" in output
+        assert "This is the Ephys Link server window." in output
+        assert __version__ in output
+        assert ASCII in output
+
+    def test_check_for_updates_is_newer(self, console: Console, mocker: MockerFixture) -> None:
+        """Test the check_for_updates function."""
+        # Add mocks and spies.
+        spied_critical_print = mocker.spy(console, "critical_print")
+
+        # Mock requests.get to return a fake response with a lower version.
+        fake_response = mocker.Mock()
+        fake_response.json.return_value = [{"name": "0.0.0"}]  # pyright: ignore [reportAny]
+        _ = mocker.patch("ephys_link.utils.startup.get", return_value=fake_response)
+
+        # Act
+        check_for_updates(console)
+
+        # Assert: critical_print should NOT be called since no update is available.
+        spied_critical_print.assert_not_called()
+
+    def test_check_for_updates_is_older(self, console: Console, mocker: MockerFixture) -> None:
+        """Test the check_for_updates function with a newer version."""
+        # Add mocks and spies.
+        spied_critical_print = mocker.spy(console, "critical_print")
+
+        # Mock the json() method of the response from get
+        fake_response = mocker.Mock()
+        fake_response.json.return_value = [{"name": "1000000.0.0"}]  # pyright: ignore [reportAny]
+        _ = mocker.patch("ephys_link.utils.startup.get", return_value=fake_response)
+
+        # Act
+        check_for_updates(console)
+
+        # Assert: critical_print should be called since an update is available.
+        spied_critical_print.assert_called()
+
+    @pytest.mark.parametrize("exception", [ConnectionError, ConnectTimeout])
+    def test_check_for_updates_connection_errors(
+        self, exception: ConnectionError | ConnectTimeout, console: Console, mocker: MockerFixture
+    ) -> None:
+        """Test the check_for_updates function with connection-related errors."""
+        # Add mocks and spies.
+        spied_error_print = mocker.spy(console, "error_print")
+
+        # Mock requests.get to raise a ConnectionError or ConnectTimeout.
+        _ = mocker.patch("ephys_link.utils.startup.get", side_effect=exception)
+
+        # Act
+        check_for_updates(console)
+
+        # Assert: error_print should be called with the correct message.
+        spied_error_print.assert_called_with("UPDATE", UNABLE_TO_CHECK_FOR_UPDATES_ERROR)
+
+    def test_get_bindings_returns_valid_bindings(self):
+        """Test that get_bindings returns a list of valid binding classes."""
+        # Act.
+        bindings = get_bindings()
+
+        # Assert.
+        assert isinstance(bindings, list)
+        assert all(issubclass(b, BaseBinding) for b in bindings)
+        assert BaseBinding not in bindings
+
+    @pytest.mark.parametrize(("cli_name", "binding"), [("fake", FakeBinding), ("pathfinder-mpm", MPMBinding)])
+    def test_get_binding_instance(
+        self, cli_name: str, binding: FakeBinding | MPMBinding, console: Console, mocker: MockerFixture
+    ):
+        """Test that get_binding_instance returns an instance of the requested binding class."""
+        # Arrange.
+        spied_error_print = mocker.spy(console, "error_print")
+        fake_options = EphysLinkOptions(type=cli_name)
+
+        # Act.
+        binding_instance = get_binding_instance(fake_options, console)
+
+        # Assert.
+        # noinspection PyTypeChecker
+        assert isinstance(binding_instance, binding)  # pyright: ignore [reportArgumentType]
+        spied_error_print.assert_not_called()
+
+    @pytest.mark.parametrize("cli_name", ["ump-4", "ump-3"])
+    def test_get_binding_instance_ump(self, cli_name: str, console: Console, mocker: MockerFixture):
+        """Test that get_binding_instance returns an instance of the UmpBinding class and handles deprecation."""
+        # Arrange.
+        spied_error_print = mocker.spy(console, "error_print")
+        fake_options = EphysLinkOptions(type=cli_name)
+        _ = mocker.patch("ephys_link.bindings.ump_binding.UmpBinding", autospec=True)
+
+        # Act.
+        with pytest.raises(ValueError, match=unrecognized_platform_type_error("ump")) as e:
+            _ = get_binding_instance(fake_options, console)
+
+        # Assert.
+        spied_error_print.assert_called_once_with("DEPRECATION", ump_4_3_deprecation_error(cli_name))
+        assert str(e.value) == unrecognized_platform_type_error("ump")