Fix radio manager to handle oversized packets gracefully (#317)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Mikefly123 <61564344+Mikefly123@users.noreply.github.com>

Author: Copilot

circuitpython-workspaces/flight-software/src/pysquared/hardware/radio/manager/base.py

@@ -73,6 +73,16 @@ def send(self, data: bytes) -> bool:
                 self._log.warning("Radio send attempt failed: Not licensed.")
                 return False
 
+            # Check if data exceeds max packet size
+            max_size = self.get_max_packet_size()
+            if len(data) > max_size:
+                self._log.warning(
+                    "Data exceeds max packet size, truncating",
+                    data_length=len(data),
+                    max_packet_size=max_size,
+                )
+                data = data[:max_size]
+
             sent = self._send_internal(data)
 
             if not sent:

cpython-workspaces/flight-software-unit-tests/src/unit-tests/hardware/radio/manager/test_radio_base.py

@@ -5,6 +5,8 @@
 the default `get_max_packet_size` returns the correct value.
 """
 
+from unittest.mock import MagicMock
+
 import pytest
 from pysquared.hardware.radio.manager.base import BaseRadioManager
 from pysquared.hardware.radio.modulation import LoRa
@@ -82,3 +84,94 @@ def test_get_max_packet_size():
 
     # Check that get_max_packet_size returns the default packet size
     assert mock_manager.get_max_packet_size() == 128  # Default value
+
+
+def test_send_oversized_packet_truncates():
+    """Tests that oversized packets are truncated and a warning is logged.
+
+    This test verifies that when a packet larger than max_packet_size is sent,
+    the BaseRadioManager logs a warning and truncates the data to max_packet_size
+    before sending.
+    """
+    # Create a mock instance of the BaseRadioManager
+    mock_manager = BaseRadioManager.__new__(BaseRadioManager)
+    mock_manager._log = MagicMock()
+    mock_manager._radio_config = MagicMock()
+    mock_manager._radio_config.license = "test_license"
+
+    # Mock get_max_packet_size to return a small value for testing
+    mock_manager.get_max_packet_size = MagicMock(return_value=10)
+
+    # Mock _send_internal to capture what data is actually sent
+    sent_data = []
+
+    def capture_send(data: bytes) -> bool:
+        """Captures sent data for verification."""
+        sent_data.append(data)
+        return True
+
+    mock_manager._send_internal = capture_send
+
+    # Create data larger than max packet size
+    oversized_data = b"This is a message that is longer than 10 bytes"
+
+    # Send the oversized data
+    result = mock_manager.send(oversized_data)
+
+    # Verify that send was successful
+    assert result is True
+
+    # Verify that a warning was logged
+    mock_manager._log.warning.assert_called_once()
+    warning_call = mock_manager._log.warning.call_args
+    assert warning_call[0][0] == "Data exceeds max packet size, truncating"
+    assert warning_call[1]["data_length"] == len(oversized_data)
+    assert warning_call[1]["max_packet_size"] == 10
+
+    # Verify that the data was truncated to max_packet_size
+    assert len(sent_data) == 1
+    assert sent_data[0] == oversized_data[:10]
+    assert len(sent_data[0]) == 10
+
+
+def test_send_exact_size_packet_no_warning():
+    """Tests that packets at exactly max_packet_size do not trigger a warning.
+
+    This test verifies that when a packet of exactly max_packet_size is sent,
+    no warning is logged and the data is sent as-is.
+    """
+    # Create a mock instance of the BaseRadioManager
+    mock_manager = BaseRadioManager.__new__(BaseRadioManager)
+    mock_manager._log = MagicMock()
+    mock_manager._radio_config = MagicMock()
+    mock_manager._radio_config.license = "test_license"
+
+    # Mock get_max_packet_size to return a small value for testing
+    mock_manager.get_max_packet_size = MagicMock(return_value=10)
+
+    # Mock _send_internal to capture what data is actually sent
+    sent_data = []
+
+    def capture_send(data: bytes) -> bool:
+        """Captures sent data for verification."""
+        sent_data.append(data)
+        return True
+
+    mock_manager._send_internal = capture_send
+
+    # Create data exactly at max packet size
+    exact_size_data = b"0123456789"  # Exactly 10 bytes
+
+    # Send the data
+    result = mock_manager.send(exact_size_data)
+
+    # Verify that send was successful
+    assert result is True
+
+    # Verify that no warning was logged about truncation
+    mock_manager._log.warning.assert_not_called()
+
+    # Verify that the data was sent as-is
+    assert len(sent_data) == 1
+    assert sent_data[0] == exact_size_data
+    assert len(sent_data[0]) == 10

cpython-workspaces/flight-software-unit-tests/src/unit-tests/hardware/radio/manager/test_rfm9x_manager.py

@@ -361,6 +361,7 @@ def test_send_success_bytes(
     mock_radio_config.modulation = "LoRa"
     mock_radio_instance = MagicMock()
     mock_radio_instance.send = MagicMock()
+    mock_radio_instance.max_packet_length = 252  # RFM9x max packet length
     mock_rfm9x.return_value = mock_radio_instance
 
     manager = RFM9xManager(
@@ -440,6 +441,7 @@ def test_send_exception(
     mock_radio_config.modulation = "LoRa"
     mock_radio_instance = MagicMock()
     mock_radio_instance.send = MagicMock()
+    mock_radio_instance.max_packet_length = 252  # RFM9x max packet length
     send_error = RuntimeError("SPI Error")
     mock_radio_instance.send.side_effect = send_error
     mock_rfm9x.return_value = mock_radio_instance
@@ -933,3 +935,63 @@ def test_get_rssi(
     rssi_value = manager.get_rssi()
 
     assert rssi_value == expected_rssi
+
+
+def test_send_oversized_packet_truncates(
+    mock_rfm9x: MagicMock,
+    mock_logger: MagicMock,
+    mock_spi: MagicMock,
+    mock_chip_select: MagicMock,
+    mock_reset: MagicMock,
+    mock_radio_config: RadioConfig,
+):
+    """Tests that oversized packets are truncated and a warning is logged.
+
+    Args:
+        mock_rfm9x: Mocked RFM9x class.
+        mock_logger: Mocked Logger instance.
+        mock_spi: Mocked SPI bus.
+        mock_chip_select: Mocked chip select pin.
+        mock_reset: Mocked reset pin.
+        mock_radio_config: Mocked RadioConfig instance.
+    """
+    mock_radio_config.modulation = "LoRa"
+    mock_radio_instance = MagicMock()
+    mock_radio_instance.max_packet_length = 252  # RFM9x max packet length
+    mock_radio_instance.send = MagicMock(return_value=True)
+    mock_rfm9x.return_value = mock_radio_instance
+
+    manager = RFM9xManager(
+        mock_logger,
+        mock_radio_config,
+        mock_spi,
+        mock_chip_select,
+        mock_reset,
+    )
+
+    # Create oversized data (253 bytes, which is 1 byte over the limit)
+    oversized_data = b"x" * 253
+
+    # Send the oversized data
+    result = manager.send(oversized_data)
+
+    # Verify that send was successful
+    assert result is True
+
+    # Verify that a warning was logged about truncation
+    mock_logger.warning.assert_called()
+    warning_calls = [call for call in mock_logger.warning.call_args_list]
+    truncation_warning = None
+    for call in warning_calls:
+        if call[0][0] == "Data exceeds max packet size, truncating":
+            truncation_warning = call
+            break
+
+    assert truncation_warning is not None
+    assert truncation_warning[1]["data_length"] == 253
+    assert truncation_warning[1]["max_packet_size"] == 252
+
+    # Verify that the data sent to the radio was truncated to 252 bytes
+    mock_radio_instance.send.assert_called_once()
+    sent_data = mock_radio_instance.send.call_args[0][0]
+    assert len(sent_data) == 252