Custom connection strings to settings.json

Author: OmkarSarkar204

.github/instructions/pytest_testing_instructions.md

@@ -297,7 +297,7 @@ class TestTemplateSelection:
 
 1. **Run tests**: `pytest tests/ -v`
 2. **Check coverage**: `pytest --cov=ardupilot_methodic_configurator --cov-report=term-missing`
-3. **Format with ruff**: `ruff formal`
+3. **Format with ruff**: `ruff format`
 4. **Lint with ruff**: `ruff check --fix`
 5. **Type check with mypy**: `mypy`
 6. **Advanced type check with pyright**: `pyright`

ardupilot_methodic_configurator/backend_filesystem_program_settings.py

@@ -75,7 +75,7 @@ def __init__(self) -> None:
         pass
 
     @classmethod
-    def _get_settings_defaults(cls) -> dict[str, Union[int, bool, str, float, dict]]:
+    def _get_settings_defaults(cls) -> dict[str, Union[int, bool, str, float, dict, list]]:
         """
         Get the default settings dictionary with dynamically computed paths.
 
@@ -89,6 +89,7 @@ def _get_settings_defaults(cls) -> dict[str, Union[int, bool, str, float, dict]]
         return {
             "Format version": 1,
             "display_usage_popup": dict.fromkeys(USAGE_POPUP_WINDOWS, True),
+            "connection_history": [],
             "directory_selection": {
                 "template_dir": os_path.join(cls.get_templates_base_dir(), "ArduCopter", "empty_4.6.x"),
                 "new_base_dir": os_path.join(settings_directory, "vehicles"),
@@ -455,3 +456,34 @@ def motor_diagram_exists(frame_class: int, frame_type: int) -> bool:
         """
         filepath, _error_msg = ProgramSettings.motor_diagram_filepath(frame_class, frame_type)
         return filepath != "" and os_path.exists(filepath)
+
+    @staticmethod
+    def get_connection_history() -> list[str]:
+        """Get the list of previously used connection strings."""
+        settings = ProgramSettings._get_settings_as_dict()
+        history: Any = settings.get("connection_history", [])
+
+        if not isinstance(history, list):
+            return []
+
+        return [item for item in history if isinstance(item, str)]
+
+    @staticmethod
+    def store_connection(connection_string: str) -> None:
+        """Save a new connection string to history."""
+        if not connection_string:
+            return
+
+        settings = ProgramSettings._get_settings_as_dict()
+        history = settings.get("connection_history", [])
+
+        if connection_string in history:
+            history.remove(connection_string)
+
+        history.insert(0, connection_string)
+
+        if len(history) > 10:
+            history = history[:10]
+
+        settings["connection_history"] = history
+        ProgramSettings._set_settings_from_dict(settings)

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -22,6 +22,7 @@
 from typing import Union
 
 from ardupilot_methodic_configurator import _, __version__
+from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
 from ardupilot_methodic_configurator.backend_flightcontroller import SUPPORTED_BAUDRATES, FlightController
 from ardupilot_methodic_configurator.common_arguments import add_common_arguments
 from ardupilot_methodic_configurator.frontend_tkinter_base_window import BaseWindow
@@ -73,6 +74,9 @@ def __init__(  # pylint: disable=too-many-arguments, too-many-positional-argumen
         # Create a label for port
         port_label = ttk.Label(selection_frame, text=_("Port:"))
         port_label.pack(side=tk.LEFT, padx=(0, 5))
+        # Load saved connection history from ProgramSettings
+        for conn in ProgramSettings.get_connection_history():
+            self.flight_controller.add_connection(conn)
 
         # Create a read-only combobox for flight controller connection selection
         self.conn_selection_combobox = PairTupleCombobox(
@@ -157,6 +161,7 @@ def add_connection(self) -> str:
             ),
         )
         if selected_connection:
+            ProgramSettings.store_connection(selected_connection)
             error_msg = _("Will add new connection: {selected_connection} if not duplicated")
             logging_debug(error_msg.format(**locals()))
             self.flight_controller.add_connection(selected_connection)

tests/test_backend_filesystem_program_settings.py

@@ -403,6 +403,7 @@ def test_user_can_load_existing_settings_file(self, mock_user_config, sample_pro
         expected_result["annotate_docs_into_param_files"] = False  # Added by default
         expected_result["gui_complexity"] = "simple"  # Added by default
         expected_result["motor_test"] = {"duration": 2, "throttle_pct": 10}  # Added by default
+        expected_result["connection_history"] = []  # Added for port connection string to save
         expected_result["display_usage_popup"]["component_editor_validation"] = True  # Added by default
         expected_result["display_usage_popup"]["workflow_explanation"] = True  # Added by default
         expected_result["display_usage_popup"]["bitmask_parameter_editor"] = True  # Added by default

tests/test_backend_filesystem_program_settings_port_save.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+BDD-style tests for the backend_filesystem_program_settings.py file.
+
+This file is part of ArduPilot Methodic Configurator. https://github.com/ArduPilot/MethodicConfigurator
+
+SPDX-FileCopyrightText: 2024-2026 Amilcar do Carmo Lucas <amilcar.lucas@iav.de>
+
+SPDX-License-Identifier: GPL-3.0-or-later
+"""
+
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from ardupilot_methodic_configurator.backend_filesystem_program_settings import ProgramSettings
+
+
+@pytest.fixture
+def mock_settings_file() -> dict[str, Any]:
+    """Fixture providing realistic settings data for testing."""
+    return {
+        "Format version": 1,
+        "display_usage_popup": {
+            "workflow_explanation": True,
+            "component_editor": False,
+        },
+        "connection_history": ["COM3", "tcp:127.0.0.1:5760"],
+        "directory_selection": {
+            "template_dir": "/path/to/template",
+            "new_base_dir": "/path/to/base",
+            "vehicle_dir": "/path/to/vehicle",
+        },
+        "auto_open_doc_in_browser": True,
+        "gui_complexity": "simple",
+        "motor_test": {
+            "duration": 2,
+            "throttle_pct": 10,
+        },
+    }
+
+
+class TestConnectionHistoryManagement:
+    """Test user connection history management workflows."""
+
+    def test_user_can_store_new_connection(self, mock_settings_file: dict[str, Any]) -> None:
+        """
+        User can save a new connection string to history.
+
+        GIVEN: A user successfully connects to a device
+        WHEN: The connection is stored
+        THEN: It should appear at the top of the connection history
+        """
+        # Arrange: Mock settings and file operations (GIVEN)
+        with (
+            patch.object(ProgramSettings, "_get_settings_as_dict", return_value=mock_settings_file),
+            patch.object(ProgramSettings, "_set_settings_from_dict") as mock_set,
+        ):
+            # Act: User stores a new connection (WHEN)
+            ProgramSettings.store_connection("udp:192.168.1.100:14550")
+
+            # Assert: New connection added to top of history (THEN)
+            mock_set.assert_called_once()
+            saved_settings = mock_set.call_args[0][0]
+            assert saved_settings["connection_history"][0] == "udp:192.168.1.100:14550"
+
+    def test_user_can_store_multiple_connections_in_order(self, mock_settings_file: dict[str, Any]) -> None:
+        """
+        User can store multiple connections and they maintain order.
+
+        GIVEN: A clean connection history
+        WHEN: The user stores multiple connection strings
+        THEN: The connections should be stored in most-recent-first order
+        """
+        # Arrange: Start with empty history (GIVEN)
+        mock_settings_file["connection_history"] = []
+
+        with (
+            patch.object(ProgramSettings, "_get_settings_as_dict", return_value=mock_settings_file),
+            patch.object(ProgramSettings, "_set_settings_from_dict") as mock_set,
+        ):
+            # Act: User stores multiple connections (WHEN)
+            ProgramSettings.store_connection("COM1")
+            ProgramSettings.store_connection("COM2")
+            ProgramSettings.store_connection("COM3")
+
+            # Assert: Connections in correct order (THEN)
+            # We check the very last call to see the final state of history
+            final_settings = mock_set.call_args[0][0]
+            history = final_settings["connection_history"]
+            assert history[0] == "COM3"  # Most recent first
+            assert history[1] == "COM2"
+            assert history[2] == "COM1"