Fix CI failures: mypy, coverage, and coordinator config_entry

- Add type: ignore[attr-defined] comments for TURN_ON/TURN_OFF
  ClimateEntityFeature attributes that aren't in homeassistant-stubs
- Pass config_entry to parent DataUpdateCoordinator.__init__() to
  fix config_entry being None in coordinator methods
- Add comprehensive tests for coordinator remote temperature features
- Coverage increased from 82.15% to 87.42%

Author: ashleigh-hopkins

custom_components/mitsubishi/climate.py

@@ -118,8 +118,8 @@ class MitsubishiClimate(MitsubishiEntity, ClimateEntity):
 
     _attr_supported_features = (
         0
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
+        | ClimateEntityFeature.TURN_ON  # type: ignore[attr-defined]
+        | ClimateEntityFeature.TURN_OFF  # type: ignore[attr-defined]
         | ClimateEntityFeature.TARGET_TEMPERATURE
         | ClimateEntityFeature.FAN_MODE
         | ClimateEntityFeature.SWING_MODE

custom_components/mitsubishi/coordinator.py

@@ -33,19 +33,18 @@ def __init__(
         scan_interval: int = DEFAULT_SCAN_INTERVAL,
     ) -> None:
         """Initialize."""
-        self.controller = controller
-        self.config_entry = config_entry
-        self.unit_info = None  # Will be populated on first update or by config flow
-        # Load persisted remote temperature mode (AC doesn't report it, so we track it)
-        self._remote_temp_mode = config_entry.options.get(CONF_REMOTE_TEMP_MODE, False)
-        self._startup_mode_applied = False
-
         super().__init__(
             hass,
             _LOGGER,
             name=DOMAIN,
+            config_entry=config_entry,
             update_interval=timedelta(seconds=scan_interval),
         )
+        self.controller = controller
+        self.unit_info = None  # Will be populated on first update or by config flow
+        # Load persisted remote temperature mode (AC doesn't report it, so we track it)
+        self._remote_temp_mode = config_entry.options.get(CONF_REMOTE_TEMP_MODE, False)
+        self._startup_mode_applied = False
 
     def set_remote_temp_mode(self, enabled: bool) -> None:
         """Set whether remote temperature mode is enabled and persist to storage."""

tests/test_coordinator.py

@@ -4,9 +4,16 @@
 from unittest.mock import AsyncMock, patch
 
 import pytest
+from homeassistant.const import CONF_HOST, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.helpers.update_coordinator import UpdateFailed
-
-from custom_components.mitsubishi.const import DEFAULT_SCAN_INTERVAL, DOMAIN
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from custom_components.mitsubishi.const import (
+    CONF_EXPERIMENTAL_FEATURES,
+    CONF_EXTERNAL_TEMP_ENTITY,
+    DEFAULT_SCAN_INTERVAL,
+    DOMAIN,
+)
 from custom_components.mitsubishi.coordinator import MitsubishiDataUpdateCoordinator
 
 
@@ -124,3 +131,225 @@ async def test_coordinator_set_remote_temp_mode(
 
     coordinator.set_remote_temp_mode(False)
     assert coordinator.remote_temp_mode is False
+
+
+@pytest.fixture
+def mock_config_entry_experimental():
+    """Create a mock config entry with experimental features enabled."""
+    return MockConfigEntry(
+        domain=DOMAIN,
+        title="Test Mitsubishi AC",
+        unique_id="00:11:22:33:44:57",
+        data={
+            CONF_HOST: "192.168.1.100",
+            "encryption_key": "unregistered",
+            "admin_username": "admin",
+            "admin_password": "password",
+            "scan_interval": 30,
+        },
+        options={
+            CONF_EXPERIMENTAL_FEATURES: True,
+            CONF_EXTERNAL_TEMP_ENTITY: "sensor.room_temp",
+        },
+        entry_id="test_entry_exp_coord_id",
+    )
+
+
+@pytest.mark.asyncio
+async def test_coordinator_experimental_features_enabled(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test experimental_features_enabled property when enabled."""
+    # Need to add config entry to hass first for options to work
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+
+    assert coordinator.experimental_features_enabled is True
+
+
+@pytest.mark.asyncio
+async def test_async_update_data_with_experimental_first_update_internal(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _async_update_data with experimental features on first update in internal mode."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    # Ensure remote mode is off
+    coordinator._remote_temp_mode = False
+
+    with patch.object(
+        hass,
+        "async_add_executor_job",
+        AsyncMock(return_value=mock_mitsubishi_controller.state),
+    ):
+        result = await coordinator._async_update_data()
+
+        assert result == mock_mitsubishi_controller.state
+        assert coordinator._startup_mode_applied is True
+
+
+@pytest.mark.asyncio
+async def test_async_update_data_with_experimental_subsequent_update_remote(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _async_update_data with experimental features on subsequent update in remote mode."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    # Simulate first update already done
+    coordinator._startup_mode_applied = True
+    coordinator._remote_temp_mode = True
+
+    # Set up a mock state for the external entity
+    hass.states.async_set("sensor.room_temp", "22.5")
+
+    with patch.object(
+        hass,
+        "async_add_executor_job",
+        AsyncMock(return_value=mock_mitsubishi_controller.state),
+    ):
+        result = await coordinator._async_update_data()
+
+        assert result == mock_mitsubishi_controller.state
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_no_entity_configured(hass, mock_mitsubishi_controller):
+    """Test _send_remote_temperature when no external entity is configured."""
+    config_entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="Test Mitsubishi AC",
+        unique_id="00:11:22:33:44:58",
+        data={CONF_HOST: "192.168.1.100"},
+        options={CONF_EXPERIMENTAL_FEATURES: True},  # No CONF_EXTERNAL_TEMP_ENTITY
+        entry_id="test_no_entity_id",
+    )
+    config_entry.add_to_hass(hass)
+
+    coordinator = MitsubishiDataUpdateCoordinator(hass, mock_mitsubishi_controller, config_entry)
+    coordinator._remote_temp_mode = True
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        # Should call set_current_temperature with None to fall back
+        mock_executor.assert_called_once()
+        assert coordinator._remote_temp_mode is False  # Should be disabled
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_entity_not_found(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _send_remote_temperature when external entity is not found."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    coordinator._remote_temp_mode = True
+    # sensor.room_temp is not set in hass.states, so get() returns None
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        # Should call set_current_temperature with None to fall back
+        mock_executor.assert_called_once()
+        assert coordinator._remote_temp_mode is False
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_entity_unavailable(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _send_remote_temperature when external entity is unavailable."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    # Set the entity state to unavailable
+    hass.states.async_set("sensor.room_temp", STATE_UNAVAILABLE)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    coordinator._remote_temp_mode = True
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        mock_executor.assert_called_once()
+        assert coordinator._remote_temp_mode is False
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_entity_unknown(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _send_remote_temperature when external entity is unknown."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    # Set the entity state to unknown
+    hass.states.async_set("sensor.room_temp", STATE_UNKNOWN)
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    coordinator._remote_temp_mode = True
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        mock_executor.assert_called_once()
+        assert coordinator._remote_temp_mode is False
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_invalid_value(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _send_remote_temperature when temperature value is invalid."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    # Set the entity state to an invalid value
+    hass.states.async_set("sensor.room_temp", "not_a_number")
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    coordinator._remote_temp_mode = True
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        mock_executor.assert_called_once()
+        assert coordinator._remote_temp_mode is False
+
+
+@pytest.mark.asyncio
+async def test_send_remote_temperature_success(
+    hass, mock_mitsubishi_controller, mock_config_entry_experimental
+):
+    """Test _send_remote_temperature with valid temperature."""
+    mock_config_entry_experimental.add_to_hass(hass)
+
+    # Set a valid temperature state
+    hass.states.async_set("sensor.room_temp", "21.5")
+
+    coordinator = MitsubishiDataUpdateCoordinator(
+        hass, mock_mitsubishi_controller, mock_config_entry_experimental
+    )
+    coordinator._remote_temp_mode = True
+
+    with patch.object(hass, "async_add_executor_job", AsyncMock()) as mock_executor:
+        await coordinator._send_remote_temperature()
+
+        mock_executor.assert_called_once()
+        # Remote mode should remain enabled on success
+        assert coordinator._remote_temp_mode is True