Add some additional tests around radio and contact management

tests/test_radio_sync.py

@@ -7,22 +7,27 @@ message polling from interfering with repeater CLI operations.
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
+from meshcore import EventType
 
+from app.models import Contact
 from app.radio_sync import (
     is_polling_paused,
     pause_polling,
     sync_radio_time,
+    sync_recent_contacts_to_radio,
 )
 
 
 @pytest.fixture(autouse=True)
-def reset_polling_state():
-    """Reset polling pause state before and after each test."""
+def reset_sync_state():
+    """Reset polling pause state and sync timestamp before and after each test."""
     import app.radio_sync as radio_sync
 
     radio_sync._polling_pause_count = 0
+    radio_sync._last_contact_sync = 0.0
     yield
     radio_sync._polling_pause_count = 0
+    radio_sync._last_contact_sync = 0.0
 
 
 class TestPollingPause:
@@ -158,3 +163,263 @@ class TestSyncRadioTime:
             result = await sync_radio_time()
 
             assert result is False
+
+
+KEY_A = "aa" * 32
+KEY_B = "bb" * 32
+
+
+def _make_contact(public_key=KEY_A, name="Alice", on_radio=False, **overrides):
+    """Create a Contact model instance for testing."""
+    defaults = {
+        "public_key": public_key,
+        "name": name,
+        "type": 0,
+        "flags": 0,
+        "last_path": None,
+        "last_path_len": -1,
+        "last_advert": None,
+        "lat": None,
+        "lon": None,
+        "last_seen": None,
+        "on_radio": on_radio,
+        "last_contacted": None,
+        "last_read_at": None,
+    }
+    defaults.update(overrides)
+    return Contact(**defaults)
+
+
+class TestSyncRecentContactsToRadio:
+    """Test the sync_recent_contacts_to_radio function."""
+
+    @pytest.mark.asyncio
+    async def test_loads_contacts_not_on_radio(self):
+        """Contacts not on radio are added via add_contact."""
+        contacts = [_make_contact(KEY_A, "Alice"), _make_contact(KEY_B, "Bob")]
+
+        mock_mc = MagicMock()
+        mock_mc.get_contact_by_key_prefix = MagicMock(return_value=None)
+        mock_result = MagicMock()
+        mock_result.type = EventType.OK
+        mock_mc.commands.add_contact = AsyncMock(return_value=mock_result)
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=contacts,
+            ),
+            patch(
+                "app.radio_sync.ContactRepository.set_on_radio",
+                new_callable=AsyncMock,
+            ) as mock_set_on_radio,
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            result = await sync_recent_contacts_to_radio()
+
+        assert result["loaded"] == 2
+        assert mock_set_on_radio.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_skips_contacts_already_on_radio(self):
+        """Contacts already on radio are counted but not re-added."""
+        contacts = [_make_contact(KEY_A, "Alice", on_radio=True)]
+
+        mock_mc = MagicMock()
+        mock_mc.get_contact_by_key_prefix = MagicMock(return_value=MagicMock())  # Found
+        mock_mc.commands.add_contact = AsyncMock()
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=contacts,
+            ),
+            patch(
+                "app.radio_sync.ContactRepository.set_on_radio",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            result = await sync_recent_contacts_to_radio()
+
+        assert result["loaded"] == 0
+        assert result["already_on_radio"] == 1
+        mock_mc.commands.add_contact.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_throttled_when_called_quickly(self):
+        """Second call within throttle window returns throttled result."""
+        mock_mc = MagicMock()
+        mock_mc.get_contact_by_key_prefix = MagicMock(return_value=None)
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=[],
+            ),
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            # First call succeeds
+            result1 = await sync_recent_contacts_to_radio()
+            assert "throttled" not in result1
+
+            # Second call is throttled
+            result2 = await sync_recent_contacts_to_radio()
+            assert result2["throttled"] is True
+            assert result2["loaded"] == 0
+
+    @pytest.mark.asyncio
+    async def test_force_bypasses_throttle(self):
+        """force=True bypasses the throttle window."""
+        mock_mc = MagicMock()
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=[],
+            ),
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            # First call
+            await sync_recent_contacts_to_radio()
+
+            # Forced second call is not throttled
+            result = await sync_recent_contacts_to_radio(force=True)
+            assert "throttled" not in result
+
+    @pytest.mark.asyncio
+    async def test_not_connected_returns_error(self):
+        """Returns error when radio is not connected."""
+        with patch("app.radio_sync.radio_manager") as mock_rm:
+            mock_rm.is_connected = False
+            mock_rm.meshcore = None
+
+            result = await sync_recent_contacts_to_radio()
+
+        assert result["loaded"] == 0
+        assert "error" in result
+
+    @pytest.mark.asyncio
+    async def test_marks_on_radio_when_found_but_not_flagged(self):
+        """Contact found on radio but not flagged gets set_on_radio(True)."""
+        contact = _make_contact(KEY_A, "Alice", on_radio=False)
+
+        mock_mc = MagicMock()
+        mock_mc.get_contact_by_key_prefix = MagicMock(return_value=MagicMock())  # Found
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=[contact],
+            ),
+            patch(
+                "app.radio_sync.ContactRepository.set_on_radio",
+                new_callable=AsyncMock,
+            ) as mock_set_on_radio,
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            result = await sync_recent_contacts_to_radio()
+
+        assert result["already_on_radio"] == 1
+        # Should update the flag since contact.on_radio was False
+        mock_set_on_radio.assert_called_once_with(KEY_A, True)
+
+    @pytest.mark.asyncio
+    async def test_handles_add_failure(self):
+        """Failed add_contact increments the failed counter."""
+        contacts = [_make_contact(KEY_A, "Alice")]
+
+        mock_mc = MagicMock()
+        mock_mc.get_contact_by_key_prefix = MagicMock(return_value=None)
+        mock_result = MagicMock()
+        mock_result.type = EventType.ERROR
+        mock_result.payload = {"error": "Radio full"}
+        mock_mc.commands.add_contact = AsyncMock(return_value=mock_result)
+
+        mock_settings = MagicMock()
+        mock_settings.max_radio_contacts = 200
+
+        with (
+            patch("app.radio_sync.radio_manager") as mock_rm,
+            patch(
+                "app.radio_sync.ContactRepository.get_recent_non_repeaters",
+                new_callable=AsyncMock,
+                return_value=contacts,
+            ),
+            patch(
+                "app.radio_sync.ContactRepository.set_on_radio",
+                new_callable=AsyncMock,
+            ),
+            patch(
+                "app.radio_sync.AppSettingsRepository.get",
+                new_callable=AsyncMock,
+                return_value=mock_settings,
+            ),
+        ):
+            mock_rm.is_connected = True
+            mock_rm.meshcore = mock_mc
+
+            result = await sync_recent_contacts_to_radio()
+
+        assert result["loaded"] == 0
+        assert result["failed"] == 1