Merge pull request #1135 from liudger/copilot/fix-1134

Increase test coverage to exceed 90%

Author: liudger

tests/test_api_initialization.py

@@ -0,0 +1,49 @@
+"""Tests for API data initialization error handling."""
+# pylint: disable=protected-access
+
+from unittest.mock import patch
+
+import pytest
+
+from bsblan import BSBLAN
+from bsblan.bsblan import BSBLANConfig
+from bsblan.constants import API_DATA_NOT_INITIALIZED_ERROR_MSG, API_VERSION_ERROR_MSG
+from bsblan.exceptions import BSBLANError
+
+
+@pytest.mark.asyncio
+async def test_initialize_api_data_no_api_version() -> None:
+    """Test initializing API data with no API version set."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # API version is None by default
+    with pytest.raises(BSBLANError, match=API_VERSION_ERROR_MSG):
+        await bsblan._initialize_api_data()
+
+
+@pytest.mark.asyncio
+async def test_initialize_api_data_unexpected_none() -> None:
+    """Test edge case where API data is still None after initialization."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Set API version but simulate data being None after initialization
+    bsblan._api_version = "v3"
+
+    # Mock API_VERSIONS to return None for this specific test
+    with patch("bsblan.bsblan.API_VERSIONS", {"v3": None}), pytest.raises(
+        BSBLANError, match=API_DATA_NOT_INITIALIZED_ERROR_MSG
+    ):
+        await bsblan._initialize_api_data()
+
+
+@pytest.mark.asyncio
+async def test_request_no_session() -> None:
+    """Test request method with no session initialized."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Session is None by default
+    with pytest.raises(BSBLANError, match="Session not initialized"):
+        await bsblan._request()

tests/test_context_manager.py

@@ -0,0 +1,72 @@
+"""Tests for BSBLAN context manager features."""
+# pylint: disable=protected-access
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from bsblan import BSBLAN
+from bsblan.bsblan import BSBLANConfig
+
+
+@pytest.mark.asyncio
+async def test_context_manager_session_creation() -> None:
+    """Test that context manager creates and closes a session."""
+    config = BSBLANConfig(host="example.com")
+
+    # Mock the initialize method to avoid actual API calls
+    with patch.object(BSBLAN, "initialize", AsyncMock()) as mock_init:
+        async with BSBLAN(config) as bsblan:
+            # Check that session was created
+            assert bsblan.session is not None
+            assert bsblan._close_session is True
+
+            # Check that initialize was called
+            mock_init.assert_called_once()
+
+        # After context exit, session.close should have been called
+        # This is implicit since we're testing the context manager behavior
+
+
+@pytest.mark.asyncio
+async def test_context_manager_with_existing_session() -> None:
+    """Test that context manager uses an existing session if provided."""
+    config = BSBLANConfig(host="example.com")
+
+    # Create a mock session
+    session = AsyncMock()
+    session.closed = False
+
+    # Mock initialize to avoid actual API calls
+    with patch.object(BSBLAN, "initialize", AsyncMock()) as mock_init:
+        async with BSBLAN(config, session=session) as bsblan:
+            # Check that our session was used
+            assert bsblan.session is session
+            assert bsblan._close_session is False
+
+            # Check that initialize was called
+            mock_init.assert_called_once()
+
+        # After context exit, session.close should not have been called
+        session.close.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_aexit_exception_handling() -> None:
+    """Test that BSBLAN doesn't swallow exceptions during session close."""
+    config = BSBLANConfig(host="example.com")
+
+    # Create a mock session with a close method that raises an exception
+    mock_session = AsyncMock()
+    mock_session.close = AsyncMock(side_effect=Exception("Test exception"))
+
+    # Patch initialize to avoid actual API calls
+    with patch.object(BSBLAN, "initialize", AsyncMock()):
+        # Create BSBLAN instance with our mock session
+        bsblan = BSBLAN(config, session=mock_session)
+        bsblan._close_session = True  # Force close on exit
+
+        # The exception from session.close should be propagated
+        with pytest.raises(Exception, match="Test exception"):
+            async with bsblan:
+                pass  # Just enter and exit the context

tests/test_entity_info.py

@@ -0,0 +1,99 @@
+"""Tests for EntityInfo value conversion error handling."""
+
+import logging
+from datetime import time
+
+import pytest
+
+from bsblan.models import DataType, EntityInfo
+
+
+def test_entity_info_invalid_time_conversion() -> None:
+    """Test EntityInfo with invalid time format."""
+    # Create EntityInfo with invalid time format
+    entity = EntityInfo(
+        name="Invalid Time",
+        value="24:61",  # Invalid time
+        unit="",
+        desc="",
+        data_type=DataType.TIME,
+    )
+
+    # The value should remain as string since conversion failed
+    assert entity.value == "24:61"
+
+
+def test_entity_info_invalid_weekday_conversion() -> None:
+    """Test EntityInfo with invalid weekday format."""
+    # Create EntityInfo with invalid weekday format
+    entity = EntityInfo(
+        name="Invalid Weekday",
+        value="not-a-number",  # Invalid weekday
+        unit="",
+        desc="",
+        data_type=DataType.WEEKDAY,
+    )
+
+    # The value should remain as string since conversion failed
+    assert entity.value == "not-a-number"
+
+
+def test_entity_info_general_conversion_error(caplog: pytest.LogCaptureFixture) -> None:
+    """Test EntityInfo with general conversion error."""
+    with caplog.at_level(logging.WARNING):
+        # Create EntityInfo that will cause a conversion error
+        entity = EntityInfo(
+            name="Error Test",
+            value=object(),  # Object that can't be converted
+            unit="",
+            desc="",
+            data_type=DataType.PLAIN_NUMBER,
+        )
+
+        # The original value should be preserved
+        assert isinstance(entity.value, object)
+        assert "Failed to convert value" in caplog.text
+
+
+def test_entity_info_valid_time_conversion() -> None:
+    """Test EntityInfo with valid time format."""
+    # Create EntityInfo with valid time format
+    entity = EntityInfo(
+        name="Valid Time",
+        value="14:30",
+        unit="",
+        desc="",
+        data_type=DataType.TIME,
+    )
+
+    # The value should be converted to a time object
+    assert isinstance(entity.value, time)
+    assert entity.value.hour == 14
+    assert entity.value.minute == 30
+
+
+def test_entity_info_enum_description() -> None:
+    """Test the enum_description property."""
+    # Create EntityInfo with ENUM data type
+    enum_entity = EntityInfo(
+        name="Test Enum",
+        value="1",
+        unit="",
+        desc="Enum Description",
+        data_type=DataType.ENUM,
+    )
+
+    # The enum_description should return the desc field
+    assert enum_entity.enum_description == "Enum Description"
+
+    # Create EntityInfo with non-ENUM data type
+    non_enum_entity = EntityInfo(
+        name="Test Value",
+        value="22",
+        unit="°C",
+        desc="Not an Enum",
+        data_type=DataType.PLAIN_NUMBER,
+    )
+
+    # The enum_description should return None
+    assert non_enum_entity.enum_description is None

tests/test_reset_validation.py

@@ -0,0 +1,51 @@
+"""Tests for APIValidator reset_validation method."""
+
+from bsblan.utility import APIValidator
+
+
+def test_reset_validation_specific_section() -> None:
+    """Test resetting validation for a specific section."""
+    # Create a test API config
+    api_config = {
+        "heating": {"param1": "value1"},
+        "sensor": {"param2": "value2"},
+    }
+
+    # Initialize APIValidator with some validated sections
+    validator = APIValidator(api_config)
+    validator.validated_sections.update({"heating", "sensor"})
+
+    # Verify initial state
+    assert validator.is_section_validated("heating") is True
+    assert validator.is_section_validated("sensor") is True
+
+    # Reset validation for just the heating section
+    validator.reset_validation("heating")
+
+    # Verify only heating was reset
+    assert validator.is_section_validated("heating") is False
+    assert validator.is_section_validated("sensor") is True
+
+
+def test_reset_validation_nonexistent_section() -> None:
+    """Test resetting validation for a section that wasn't validated."""
+    # Create a test API config
+    api_config = {
+        "heating": {"param1": "value1"},
+        "sensor": {"param2": "value2"},
+    }
+
+    # Initialize APIValidator with some validated sections
+    validator = APIValidator(api_config)
+    validator.validated_sections.add("heating")
+
+    # Verify initial state
+    assert validator.is_section_validated("heating") is True
+    assert validator.is_section_validated("nonexistent") is False
+
+    # Reset validation for a nonexistent section (should not error)
+    validator.reset_validation("nonexistent")
+
+    # Verify state remains unchanged
+    assert validator.is_section_validated("heating") is True
+    assert validator.is_section_validated("nonexistent") is False

tests/test_temperature_unit.py

@@ -0,0 +1,97 @@
+"""Tests for temperature unit handling in BSBLAN."""
+# pylint: disable=protected-access
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from bsblan import BSBLAN
+from bsblan.bsblan import BSBLANConfig
+from bsblan.models import EntityInfo, StaticState
+
+
+@pytest.mark.asyncio
+async def test_temperature_unit_getter() -> None:
+    """Test the get_temperature_unit property."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Test default unit
+    assert bsblan.get_temperature_unit == "°C"
+
+    # Test with custom unit set
+    bsblan._temperature_unit = "°F"
+    assert bsblan.get_temperature_unit == "°F"
+
+
+@pytest.mark.asyncio
+async def test_initialize_temperature_range_celsius() -> None:
+    """Test initialization of temperature range with Celsius unit."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Create mock static values with Celsius unit
+    min_temp = EntityInfo(name="Min Temp", value="10", unit="°C", desc="", data_type=0)
+    max_temp = EntityInfo(name="Max Temp", value="30", unit="°C", desc="", data_type=0)
+    static_values = StaticState(min_temp=min_temp, max_temp=max_temp)
+
+    # Mock static_values method to return our test data
+    with patch.object(bsblan, "static_values", AsyncMock(return_value=static_values)):
+        await bsblan._initialize_temperature_range()
+
+        # Verify temperature range was set correctly
+        assert bsblan._min_temp == 10.0
+        assert bsblan._max_temp == 30.0
+        assert bsblan._temperature_range_initialized is True
+        assert bsblan._temperature_unit == "°C"
+
+
+@pytest.mark.asyncio
+async def test_initialize_temperature_range_fahrenheit() -> None:
+    """Test initialization of temperature range with Fahrenheit unit."""
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Create mock static values with Fahrenheit unit
+    min_temp = EntityInfo(name="Min Temp", value="50", unit="°F", desc="", data_type=0)
+    max_temp = EntityInfo(name="Max Temp", value="86", unit="°F", desc="", data_type=0)
+    static_values = StaticState(min_temp=min_temp, max_temp=max_temp)
+
+    # Mock static_values method to return our test data
+    with patch.object(bsblan, "static_values", AsyncMock(return_value=static_values)):
+        await bsblan._initialize_temperature_range()
+
+        # Verify temperature range was set correctly
+        assert bsblan._min_temp == 50.0
+        assert bsblan._max_temp == 86.0
+        assert bsblan._temperature_range_initialized is True
+        assert bsblan._temperature_unit == "°F"
+
+
+@pytest.mark.asyncio
+async def test_initialize_temperature_range_alternate_celsius_format() -> None:
+    """Test initialization of temperature range with alternate Celsius format.
+
+    Tests with HTML entity format (°C) instead of unicode character.
+    """
+    config = BSBLANConfig(host="example.com")
+    bsblan = BSBLAN(config)
+
+    # Create mock static values with HTML degree symbol
+    min_temp = EntityInfo(
+        name="Min Temp", value="10", unit="°C", desc="", data_type=0
+    )
+    max_temp = EntityInfo(
+        name="Max Temp", value="30", unit="°C", desc="", data_type=0
+    )
+    static_values = StaticState(min_temp=min_temp, max_temp=max_temp)
+
+    # Mock static_values method to return our test data
+    with patch.object(bsblan, "static_values", AsyncMock(return_value=static_values)):
+        await bsblan._initialize_temperature_range()
+
+        # Verify temperature range was set correctly
+        assert bsblan._min_temp == 10.0
+        assert bsblan._max_temp == 30.0
+        assert bsblan._temperature_range_initialized is True
+        assert bsblan._temperature_unit == "°C"