feat: increase coverage threshold to 70% and add dedicated tests (#27)

* feat: increase coverage threshold to 70% and add dedicated tests

- Update fail_under from 50 to 70 in pyproject.toml
- Add comprehensive test suite for serial_reader.py (23 tests)
- Add comprehensive test suite for telegram_notifier.py (29 tests)
- Achieved 84.48% total coverage

* style: fix black formatting in test_serial.py

* style: remove unused import in test_serial.py

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: bryamzxz

pyproject.toml

@@ -91,7 +91,7 @@ branch = true
 omit = ["*/tests/*", "*/__main__.py"]
 
 [tool.coverage.report]
-fail_under = 50
+fail_under = 70
 show_missing = true
 exclude_lines = [
     "pragma: no cover",

tests/test_serial.py

@@ -0,0 +1,295 @@
+"""Tests for sensor_app.serial_reader module."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+import serial
+
+from sensor_app.config import Settings
+from sensor_app.serial_reader import ArduinoConnection
+
+
+@pytest.fixture
+def settings() -> Settings:
+    """Create test settings."""
+    return Settings(
+        _env_file=None,
+        telegram_token="test_token",
+        telegram_chat_id="123456",
+        arduino_vid=0x2341,
+        arduino_pid=0x1002,
+        max_serial_retries=3,
+        serial_retry_delay=1,
+    )
+
+
+@pytest.fixture
+def arduino(settings: Settings) -> ArduinoConnection:
+    """Create ArduinoConnection instance."""
+    return ArduinoConnection(settings)
+
+
+class TestArduinoConnectionInit:
+    """Tests for ArduinoConnection initialization."""
+
+    def test_init_sets_settings(self, settings: Settings) -> None:
+        """Test that settings are stored on initialization."""
+        conn = ArduinoConnection(settings)
+        assert conn.settings is settings
+
+    def test_init_serial_is_none(self, arduino: ArduinoConnection) -> None:
+        """Test that serial connection starts as None."""
+        assert arduino._serial is None
+
+
+class TestArduinoConnectionIsConnected:
+    """Tests for is_connected property."""
+
+    def test_is_connected_false_when_none(self, arduino: ArduinoConnection) -> None:
+        """Test is_connected returns False when serial is None."""
+        assert arduino.is_connected is False
+
+    def test_is_connected_false_when_closed(self, arduino: ArduinoConnection) -> None:
+        """Test is_connected returns False when serial is closed."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = False
+        arduino._serial = mock_serial
+        assert arduino.is_connected is False
+
+    def test_is_connected_true_when_open(self, arduino: ArduinoConnection) -> None:
+        """Test is_connected returns True when serial is open."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        arduino._serial = mock_serial
+        assert arduino.is_connected is True
+
+
+class TestArduinoConnectionDetectPort:
+    """Tests for detect_port method."""
+
+    def test_detect_port_found(self, arduino: ArduinoConnection) -> None:
+        """Test detect_port returns device when Arduino found."""
+        mock_port = MagicMock()
+        mock_port.vid = 0x2341
+        mock_port.pid = 0x1002
+        mock_port.device = "/dev/ttyACM0"
+
+        with patch("serial.tools.list_ports.comports", return_value=[mock_port]):
+            result = arduino.detect_port()
+            assert result == "/dev/ttyACM0"
+
+    def test_detect_port_not_found(self, arduino: ArduinoConnection) -> None:
+        """Test detect_port returns None when Arduino not found."""
+        mock_port = MagicMock()
+        mock_port.vid = 0x1111
+        mock_port.pid = 0x2222
+        mock_port.device = "/dev/ttyUSB0"
+
+        with patch("serial.tools.list_ports.comports", return_value=[mock_port]):
+            result = arduino.detect_port()
+            assert result is None
+
+    def test_detect_port_empty_list(self, arduino: ArduinoConnection) -> None:
+        """Test detect_port returns None when no ports found."""
+        with patch("serial.tools.list_ports.comports", return_value=[]):
+            result = arduino.detect_port()
+            assert result is None
+
+
+class TestArduinoConnectionConnect:
+    """Tests for connect method."""
+
+    def test_connect_success(self, arduino: ArduinoConnection) -> None:
+        """Test successful connection to Arduino."""
+        mock_serial_instance = MagicMock()
+
+        with (
+            patch.object(arduino, "detect_port", return_value="/dev/ttyACM0"),
+            patch("serial.Serial", return_value=mock_serial_instance),
+        ):
+            result = arduino.connect()
+            assert result is mock_serial_instance
+            assert arduino._serial is mock_serial_instance
+            mock_serial_instance.reset_input_buffer.assert_called_once()
+
+    def test_connect_retries_on_no_port(self, arduino: ArduinoConnection) -> None:
+        """Test connect retries when port not detected."""
+        mock_serial_instance = MagicMock()
+        call_count = 0
+
+        def detect_port_side_effect() -> str | None:
+            nonlocal call_count
+            call_count += 1
+            if call_count < 2:
+                return None
+            return "/dev/ttyACM0"
+
+        with (
+            patch.object(arduino, "detect_port", side_effect=detect_port_side_effect),
+            patch("serial.Serial", return_value=mock_serial_instance),
+            patch("time.sleep"),
+        ):
+            result = arduino.connect()
+            assert result is mock_serial_instance
+
+    def test_connect_fails_after_max_retries(self, arduino: ArduinoConnection) -> None:
+        """Test connect raises exception after max retries."""
+        with (
+            patch.object(arduino, "detect_port", return_value=None),
+            patch("time.sleep"),
+        ):
+            with pytest.raises(serial.SerialException, match="Failed to connect"):
+                arduino.connect(max_retries=2)
+
+    def test_connect_handles_serial_exception(self, arduino: ArduinoConnection) -> None:
+        """Test connect handles SerialException during open."""
+        with (
+            patch.object(arduino, "detect_port", return_value="/dev/ttyACM0"),
+            patch(
+                "serial.Serial",
+                side_effect=serial.SerialException("Port busy"),
+            ),
+            patch("time.sleep"),
+        ):
+            with pytest.raises(serial.SerialException, match="Failed to connect"):
+                arduino.connect(max_retries=2)
+
+
+class TestArduinoConnectionClose:
+    """Tests for close method."""
+
+    def test_close_when_open(self, arduino: ArduinoConnection) -> None:
+        """Test close properly closes open connection."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        arduino._serial = mock_serial
+
+        arduino.close()
+
+        mock_serial.close.assert_called_once()
+        assert arduino._serial is None
+
+    def test_close_when_already_closed(self, arduino: ArduinoConnection) -> None:
+        """Test close handles already closed connection."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = False
+        arduino._serial = mock_serial
+
+        arduino.close()
+
+        mock_serial.close.assert_not_called()
+        assert arduino._serial is None
+
+    def test_close_when_none(self, arduino: ArduinoConnection) -> None:
+        """Test close handles None serial gracefully."""
+        arduino._serial = None
+        arduino.close()
+        assert arduino._serial is None
+
+    def test_close_handles_exception(self, arduino: ArduinoConnection) -> None:
+        """Test close handles exception during close."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        mock_serial.close.side_effect = Exception("Close error")
+        arduino._serial = mock_serial
+
+        arduino.close()
+
+        assert arduino._serial is None
+
+
+class TestArduinoConnectionReconnect:
+    """Tests for reconnect method."""
+
+    def test_reconnect_closes_and_connects(self, arduino: ArduinoConnection) -> None:
+        """Test reconnect closes existing and creates new connection."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        arduino._serial = mock_serial
+
+        new_serial = MagicMock()
+
+        with (
+            patch.object(arduino, "connect", return_value=new_serial),
+            patch("time.sleep"),
+        ):
+            result = arduino.reconnect()
+
+        mock_serial.close.assert_called_once()
+        assert result is new_serial
+
+
+class TestArduinoConnectionReadLine:
+    """Tests for read_line method."""
+
+    def test_read_line_success(self, arduino: ArduinoConnection) -> None:
+        """Test successful line read."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        mock_serial.readline.return_value = b"Temperature: 25.5\r\n"
+        arduino._serial = mock_serial
+
+        result = arduino.read_line()
+
+        assert result == "Temperature: 25.5"
+
+    def test_read_line_not_connected(self, arduino: ArduinoConnection) -> None:
+        """Test read_line returns None when not connected."""
+        arduino._serial = None
+        result = arduino.read_line()
+        assert result is None
+
+    def test_read_line_handles_exception(self, arduino: ArduinoConnection) -> None:
+        """Test read_line handles SerialException."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        mock_serial.readline.side_effect = serial.SerialException("Read error")
+        arduino._serial = mock_serial
+
+        result = arduino.read_line()
+
+        assert result is None
+
+
+class TestArduinoConnectionReadSensorBlock:
+    """Tests for read_sensor_block method."""
+
+    def test_read_sensor_block_success(self, arduino: ArduinoConnection) -> None:
+        """Test successful block read."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        mock_serial.timeout = 2
+        mock_serial.readline.side_effect = [
+            b"TMP117: 25.5\r\n",
+            b"BME680: 26.0\r\n",
+            b"Humidity: 45.0\r\n",
+        ]
+        arduino._serial = mock_serial
+
+        result = arduino.read_sensor_block(num_lines=3)
+
+        assert result == ["TMP117: 25.5", "BME680: 26.0", "Humidity: 45.0"]
+        assert mock_serial.timeout == 2
+
+    def test_read_sensor_block_not_connected(self, arduino: ArduinoConnection) -> None:
+        """Test read_sensor_block returns None when not connected."""
+        arduino._serial = None
+        result = arduino.read_sensor_block()
+        assert result is None
+
+    def test_read_sensor_block_handles_exception(
+        self, arduino: ArduinoConnection
+    ) -> None:
+        """Test read_sensor_block handles SerialException."""
+        mock_serial = MagicMock()
+        mock_serial.is_open = True
+        mock_serial.timeout = 2
+        mock_serial.readline.side_effect = serial.SerialException("Read error")
+        arduino._serial = mock_serial
+
+        result = arduino.read_sensor_block()
+
+        assert result is None
+        assert mock_serial.timeout == 2