feat(autoresize combobox): Make the tests more robust when running in a uv managed environment

Converted the tests from unittests to BDD-pytests

✅ Fixed the root fixture - Changed it from function scope to session scope to prevent multiple Tk instance creation
✅ Improved cleanup - Used contextlib.suppress() for better error handling
✅ Added proper imports - Added the missing contextlib import
The environment issue:

Your UV-managed Python installation is missing critical Tcl/Tk library files
The system Python works perfectly for Tkinter applicationss

Author: amilcarlucas

tests/test_frontend_tkinter_autoresize_combobox.py

@@ -10,110 +10,275 @@
 SPDX-License-Identifier: GPL-3.0-or-later
 """
 
+import contextlib
 import tkinter as tk
-import unittest
+from collections.abc import Generator
 from tkinter import ttk
 from unittest.mock import patch
 
-from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import (
-    AutoResizeCombobox,
-    update_combobox_width,
-)
+import pytest
 
+from ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox import AutoResizeCombobox, update_combobox_width
 
-class TestUpdateComboboxWidth(unittest.TestCase):
+
+@pytest.fixture(scope="session")
+def root() -> Generator[tk.Tk, None, None]:
+    """Create and clean up Tk root window for testing."""
+    # Try to reuse existing root or create new one
+    try:
+        root = tk._default_root  # type: ignore[attr-defined]
+        if root is None:
+            root = tk.Tk()
+    except (AttributeError, tk.TclError):
+        root = tk.Tk()
+
+    root.withdraw()  # Hide the main window during tests
+
+    # Patch the iconphoto method to prevent errors with mock PhotoImage
+    original_iconphoto = root.iconphoto
+
+    def mock_iconphoto(*args, **kwargs) -> None:
+        pass
+
+    root.iconphoto = mock_iconphoto  # type: ignore[method-assign]
+
+    yield root
+
+    # Restore original method and destroy root
+    root.iconphoto = original_iconphoto  # type: ignore[method-assign]
+
+    # Only destroy if we're the last test
+    with contextlib.suppress(tk.TclError):
+        root.quit()  # Close the event loop
+
+
+@pytest.fixture
+def test_combobox(root: tk.Tk) -> ttk.Combobox:
+    """Create a test combobox for width testing."""
+    frame = ttk.Frame(root)
+    frame.pack()
+    return ttk.Combobox(frame)
+
+
+class TestUpdateComboboxWidth:
     """Test cases for the update_combobox_width function."""
 
-    def test_update_combobox_width(self) -> None:
-        combobox = ttk.Combobox(values=["short", "longer", "longest"])
-        update_combobox_width(combobox)
-        assert combobox.cget("width") == 7
+    def test_combobox_width_adjusts_to_longest_value(self, test_combobox: ttk.Combobox) -> None:
+        """
+        Combobox width adjusts automatically to accommodate the longest value.
+
+        GIVEN: A combobox with values of different lengths
+        WHEN: The update_combobox_width function is called
+        THEN: The width should be set to accommodate the longest value
+        """
+        # Arrange (Given): Set combobox values with different lengths
+        test_combobox["values"] = ["short", "longer", "longest"]
+
+        # Act (When): Update the combobox width
+        update_combobox_width(test_combobox)
+
+        # Assert (Then): Width should accommodate longest value (7 characters)
+        assert test_combobox.cget("width") == 7
+
+    def test_combobox_uses_minimum_width_when_values_empty(self, test_combobox: ttk.Combobox) -> None:
+        """
+        Combobox uses minimum width when no values are present.
+
+        GIVEN: A combobox with no values
+        WHEN: The update_combobox_width function is called
+        THEN: The width should be set to the minimum value (4)
+        """
+        # Arrange (Given): Set empty values
+        test_combobox["values"] = []
+
+        # Act (When): Update the combobox width
+        update_combobox_width(test_combobox)
+
+        # Assert (Then): Should use minimum width
+        assert test_combobox.cget("width") == 4
 
-    def test_update_combobox_width_empty_values(self) -> None:
-        combobox = ttk.Combobox(values=[])
-        update_combobox_width(combobox)
-        # Should use the minimum width (4) when no values
-        assert combobox.cget("width") == 4
+    def test_combobox_uses_minimum_width_for_very_short_values(self, test_combobox: ttk.Combobox) -> None:
+        """
+        Combobox uses minimum width when all values are very short.
 
-    def test_update_combobox_width_very_short_values(self) -> None:
-        combobox = ttk.Combobox(values=["a", "b", "c"])
-        update_combobox_width(combobox)
-        # Should use the minimum width (4) when values are short
-        assert combobox.cget("width") == 4
+        GIVEN: A combobox with very short values
+        WHEN: The update_combobox_width function is called
+        THEN: The width should be set to the minimum value (4)
+        """
+        # Arrange (Given): Set very short values
+        test_combobox["values"] = ["a", "b", "c"]
 
+        # Act (When): Update the combobox width
+        update_combobox_width(test_combobox)
 
-class TestAutoResizeCombobox(unittest.TestCase):
+        # Assert (Then): Should use minimum width
+        assert test_combobox.cget("width") == 4
+
+
+@pytest.fixture
+def auto_resize_combobox(root: tk.Tk) -> AutoResizeCombobox:
+    """Create an AutoResizeCombobox for testing."""
+    frame = ttk.Frame(root)
+    frame.pack()
+    return AutoResizeCombobox(frame, values=["one", "two", "three"], selected_element="two", tooltip="Test Tooltip")
+
+
+class TestAutoResizeCombobox:
     """Test cases for the AutoResizeCombobox class."""
 
-    def setUp(self) -> None:
-        self.root = tk.Tk()
-        self.root.withdraw()  # Hide the main window during tests
-        self.combobox = AutoResizeCombobox(
-            self.root, values=["one", "two", "three"], selected_element="two", tooltip="Test Tooltip"
-        )
+    def test_user_can_see_initial_selection_in_combobox(self, auto_resize_combobox: AutoResizeCombobox) -> None:
+        """
+        User can see the initially selected value in the combobox.
+
+        GIVEN: An AutoResizeCombobox with predefined values and initial selection
+        WHEN: The combobox is created with "two" as selected element
+        THEN: The combobox should display "two" as the current value
+        """
+        # Arrange (Given): AutoResizeCombobox created with initial selection
+        # Act (When): Check the current value (already set during creation)
+        # Assert (Then): Should display the initially selected value
+        assert auto_resize_combobox.get() == "two"
 
-    def tearDown(self) -> None:
-        self.root.destroy()
+    def test_user_can_update_combobox_values_and_selection(self, auto_resize_combobox: AutoResizeCombobox) -> None:
+        """
+        User can update both the available values and current selection.
 
-    def test_initial_selection(self) -> None:
-        assert self.combobox.get() == "two"
+        GIVEN: An existing AutoResizeCombobox with initial values
+        WHEN: New values and selection are set using set_entries_tuple
+        THEN: The combobox should reflect the new values and selection
+        """
+        # Arrange (Given): Existing combobox with initial values
+        new_values = ["four", "five", "six"]
+        new_selection = "five"
 
-    def test_update_values(self) -> None:
-        self.combobox.set_entries_tuple(["four", "five", "six"], "five")
-        assert self.combobox.get() == "five"
-        assert self.combobox["values"] == ("four", "five", "six")
+        # Act (When): Update values and selection
+        auto_resize_combobox.set_entries_tuple(new_values, new_selection)
 
-    def test_set_entries_with_spaces(self) -> None:
-        """Test values with spaces."""
-        values = ["option one", "option  two", "option   three"]
-        self.combobox.set_entries_tuple(values, "option  two")
-        assert self.combobox["values"] == tuple(values)
-        assert self.combobox.get() == "option  two"
+        # Assert (Then): Should display new values and selection
+        assert auto_resize_combobox.get() == new_selection
+        assert auto_resize_combobox["values"] == tuple(new_values)
+
+    def test_combobox_handles_values_with_spaces_correctly(self, auto_resize_combobox: AutoResizeCombobox) -> None:
+        """
+        Combobox preserves values with spaces exactly as provided.
+
+        GIVEN: Values containing various amounts of spaces
+        WHEN: These values are set in the combobox
+        THEN: All spaces should be preserved exactly
+        """
+        # Arrange (Given): Values with different space patterns
+        values_with_spaces = ["option one", "option  two", "option   three"]
+        selected_value = "option  two"
+
+        # Act (When): Set values with spaces
+        auto_resize_combobox.set_entries_tuple(values_with_spaces, selected_value)
+
+        # Assert (Then): Spaces should be preserved
+        assert auto_resize_combobox["values"] == tuple(values_with_spaces)
+        assert auto_resize_combobox.get() == selected_value
 
     @patch("ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox.logging_error")
-    def test_set_entries_invalid_selection(self, mock_logging_error) -> None:
-        """Test when selected element is not in values list."""
-        values = ["one", "two", "three"]
-        self.combobox.set_entries_tuple(values, "four")
+    def test_system_logs_error_when_invalid_selection_provided(
+        self, mock_logging_error, auto_resize_combobox: AutoResizeCombobox
+    ) -> None:
+        """
+        System logs an error when user provides invalid selection.
+
+        GIVEN: A combobox with valid values
+        WHEN: An invalid selection that's not in the values list is provided
+        THEN: An error should be logged and the selection should remain unchanged
+        """
+        # Arrange (Given): Valid values and invalid selection
+        valid_values = ["one", "two", "three"]
+        invalid_selection = "four"
+        original_value = auto_resize_combobox.get()
 
-        # Should log an error
+        # Act (When): Try to set invalid selection
+        auto_resize_combobox.set_entries_tuple(valid_values, invalid_selection)
+
+        # Assert (Then): Error logged and value unchanged
         mock_logging_error.assert_called_once()
-        # Selected value should not be set
-        assert self.combobox.get() == "two"  # Maintains previous value
+        assert auto_resize_combobox.get() == original_value
 
     @patch("ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox.logging_warning")
-    def test_set_entries_no_selection(self, mock_logging_warning) -> None:
-        """Test when no selection is provided."""
-        values = ["one", "two", "three"]
-        self.combobox.set_entries_tuple(values, "")
+    def test_system_logs_warning_when_no_selection_provided(
+        self, mock_logging_warning, auto_resize_combobox: AutoResizeCombobox
+    ) -> None:
+        """
+        System logs a warning when no selection is provided.
+
+        GIVEN: A combobox with valid values
+        WHEN: An empty selection is provided
+        THEN: A warning should be logged
+        """
+        # Arrange (Given): Valid values and empty selection
+        valid_values = ["one", "two", "three"]
+        empty_selection = ""
+
+        # Act (When): Set empty selection
+        auto_resize_combobox.set_entries_tuple(valid_values, empty_selection)
 
-        # Should log a warning
+        # Assert (Then): Warning should be logged
         mock_logging_warning.assert_called_once()
 
     @patch("ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox.update_combobox_width")
-    def test_set_entries_empty_values(self, mock_update_width) -> None:
-        """Test behavior with empty values list."""
-        self.combobox.set_entries_tuple([], "")
+    def test_width_update_skipped_for_empty_values(self, mock_update_width, auto_resize_combobox: AutoResizeCombobox) -> None:
+        """
+        Width update is not called when values list is empty.
+
+        GIVEN: A combobox that supports width updating
+        WHEN: An empty values list is provided
+        THEN: The width update function should not be called
+        """
+        # Arrange (Given): Empty values list
+        empty_values = []
+
+        # Act (When): Set empty values
+        auto_resize_combobox.set_entries_tuple(empty_values, "")
 
-        # Width update should not be called with empty values
+        # Assert (Then): Width update should not be called
         mock_update_width.assert_not_called()
 
     @patch("ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox.show_tooltip")
-    def test_tooltip_display(self, mock_show_tooltip) -> None:
-        """Test tooltip is shown when provided."""
-        self.combobox.set_entries_tuple(["one", "two"], "one", "Help text")
+    def test_tooltip_displays_when_help_text_provided(
+        self, mock_show_tooltip, auto_resize_combobox: AutoResizeCombobox
+    ) -> None:
+        """
+        Tooltip is displayed when help text is provided.
 
-        # Tooltip should be shown
-        mock_show_tooltip.assert_called_once_with(self.combobox, "Help text")
+        GIVEN: A combobox that supports tooltips
+        WHEN: Values are set with tooltip text provided
+        THEN: The tooltip should be displayed with the help text
+        """
+        # Arrange (Given): Values and help text
+        values = ["one", "two"]
+        selection = "one"
+        help_text = "Help text"
+
+        # Act (When): Set values with tooltip
+        auto_resize_combobox.set_entries_tuple(values, selection, help_text)
+
+        # Assert (Then): Tooltip should be shown
+        mock_show_tooltip.assert_called_once_with(auto_resize_combobox, help_text)
 
     @patch("ardupilot_methodic_configurator.frontend_tkinter_autoresize_combobox.show_tooltip")
-    def test_no_tooltip_when_none(self, mock_show_tooltip) -> None:
-        """Test tooltip is not shown when None."""
-        self.combobox.set_entries_tuple(["one", "two"], "one", None)
+    def test_tooltip_not_displayed_when_no_help_text(
+        self, mock_show_tooltip, auto_resize_combobox: AutoResizeCombobox
+    ) -> None:
+        """
+        Tooltip is not displayed when no help text is provided.
 
-        # Tooltip should not be shown
-        mock_show_tooltip.assert_not_called()
+        GIVEN: A combobox that supports tooltips
+        WHEN: Values are set with None as tooltip text
+        THEN: The tooltip should not be displayed
+        """
+        # Arrange (Given): Values without help text
+        values = ["one", "two"]
+        selection = "one"
+        no_help_text = None
 
+        # Act (When): Set values without tooltip
+        auto_resize_combobox.set_entries_tuple(values, selection, no_help_text)
 
-if __name__ == "__main__":
-    unittest.main()
+        # Assert (Then): Tooltip should not be shown
+        mock_show_tooltip.assert_not_called()