Complete test coverage for velux light and cover entities (home-assistant#156770)

Co-authored-by: Franck Nijhof <[email protected]>

Author: wollew

homeassistant/components/velux/quality_scale.yaml

@@ -37,7 +37,7 @@ rules:
   reauthentication-flow: todo
   test-coverage:
     status: todo
-    comment: cleanup mock_config_entry vs mock_user_config_entry, cleanup mock_pyvlx vs mock_velux_client, remove unused freezer in test_cover_closed, add tests where missing
+    comment: add tests where missing
 
   # Gold
   devices:

tests/components/velux/test_cover.py

@@ -5,23 +5,44 @@
 import pytest
 from pyvlx.opening_device import Awning, GarageDoor, Gate, RollerShutter, Window
 
+from homeassistant.components.cover import (
+    ATTR_POSITION,
+    ATTR_TILT_POSITION,
+    DOMAIN as COVER_DOMAIN,
+    SERVICE_CLOSE_COVER,
+    SERVICE_CLOSE_COVER_TILT,
+    SERVICE_OPEN_COVER,
+    SERVICE_OPEN_COVER_TILT,
+    SERVICE_SET_COVER_POSITION,
+    SERVICE_SET_COVER_TILT_POSITION,
+    SERVICE_STOP_COVER,
+    SERVICE_STOP_COVER_TILT,
+)
 from homeassistant.components.velux import DOMAIN
-from homeassistant.const import STATE_CLOSED, STATE_OPEN, Platform
+from homeassistant.const import (
+    STATE_CLOSED,
+    STATE_CLOSING,
+    STATE_OPEN,
+    STATE_OPENING,
+    Platform,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
 from . import update_callback_entity
 
 from tests.common import MockConfigEntry, SnapshotAssertion, snapshot_platform
 
+# Apply setup_integration fixture to all tests in this module
+pytestmark = pytest.mark.usefixtures("setup_integration")
+
 
 @pytest.fixture
 def platform() -> Platform:
     """Fixture to specify platform to test."""
     return Platform.COVER
 
 
-@pytest.mark.usefixtures("setup_integration")
 @pytest.mark.parametrize("mock_pyvlx", ["mock_blind"], indirect=True)
 async def test_blind_entity_setup(
     hass: HomeAssistant,
@@ -38,7 +59,6 @@ async def test_blind_entity_setup(
     )
 
 
-@pytest.mark.usefixtures("setup_integration")
 @pytest.mark.usefixtures("mock_cover_type")
 @pytest.mark.parametrize(
     "mock_cover_type", [Awning, GarageDoor, Gate, RollerShutter, Window], indirect=True
@@ -63,7 +83,6 @@ async def test_cover_entity_setup(
     )
 
 
-@pytest.mark.usefixtures("setup_integration")
 async def test_cover_device_association(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
@@ -91,7 +110,6 @@ async def test_cover_device_association(
         ) in via_device_entry.identifiers
 
 
-@pytest.mark.usefixtures("setup_integration")
 async def test_cover_closed(
     hass: HomeAssistant,
     mock_window: AsyncMock,
@@ -117,3 +135,164 @@ async def test_cover_closed(
     state = hass.states.get(test_entity_id)
     assert state is not None
     assert state.state == STATE_CLOSED
+
+
+# Window command tests
+
+
+async def test_window_open_close_stop_services(
+    hass: HomeAssistant, mock_window: AsyncMock
+) -> None:
+    """Verify open/close/stop services map to device calls with no wait."""
+
+    entity_id = "cover.test_window"
+
+    await hass.services.async_call(
+        COVER_DOMAIN, SERVICE_OPEN_COVER, {"entity_id": entity_id}, blocking=True
+    )
+    mock_window.open.assert_awaited_once_with(wait_for_completion=False)
+
+    await hass.services.async_call(
+        COVER_DOMAIN, SERVICE_CLOSE_COVER, {"entity_id": entity_id}, blocking=True
+    )
+    mock_window.close.assert_awaited_once_with(wait_for_completion=False)
+
+    await hass.services.async_call(
+        COVER_DOMAIN, SERVICE_STOP_COVER, {"entity_id": entity_id}, blocking=True
+    )
+    mock_window.stop.assert_awaited_once_with(wait_for_completion=False)
+
+
+async def test_window_set_cover_position_inversion(
+    hass: HomeAssistant, mock_window: AsyncMock
+) -> None:
+    """HA position is inverted for device's Position."""
+
+    entity_id = "cover.test_window"
+
+    # Call with position 30 (=70% for device)
+    await hass.services.async_call(
+        COVER_DOMAIN,
+        SERVICE_SET_COVER_POSITION,
+        {"entity_id": entity_id, ATTR_POSITION: 30},
+        blocking=True,
+    )
+
+    # Expect device Position 70%
+    args, kwargs = mock_window.set_position.await_args
+    position_obj = args[0]
+    assert position_obj.position_percent == 70
+    assert kwargs.get("wait_for_completion") is False
+
+
+async def test_window_current_position_and_opening_closing_states(
+    hass: HomeAssistant, mock_window: AsyncMock
+) -> None:
+    """Validate current_position and opening/closing state transitions."""
+
+    entity_id = "cover.test_window"
+
+    # device position 30 -> current_position 70
+    mock_window.position.position_percent = 30
+    await update_callback_entity(hass, mock_window)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert state.attributes.get("current_position") == 70
+    assert state.state == STATE_OPEN
+
+    # Opening
+    mock_window.is_opening = True
+    mock_window.is_closing = False
+    await update_callback_entity(hass, mock_window)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert state.state == STATE_OPENING
+
+    # Closing
+    mock_window.is_opening = False
+    mock_window.is_closing = True
+    await update_callback_entity(hass, mock_window)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert state.state == STATE_CLOSING
+
+
+# Blind command tests
+
+
+async def test_blind_open_close_stop_tilt_services(
+    hass: HomeAssistant, mock_blind: AsyncMock
+) -> None:
+    """Verify tilt services map to orientation calls."""
+
+    entity_id = "cover.test_blind"
+
+    await hass.services.async_call(
+        COVER_DOMAIN,
+        SERVICE_OPEN_COVER_TILT,
+        {"entity_id": entity_id},
+        blocking=True,
+    )
+    mock_blind.open_orientation.assert_awaited_once_with(wait_for_completion=False)
+
+    await hass.services.async_call(
+        COVER_DOMAIN,
+        SERVICE_CLOSE_COVER_TILT,
+        {"entity_id": entity_id},
+        blocking=True,
+    )
+    mock_blind.close_orientation.assert_awaited_once_with(wait_for_completion=False)
+
+    await hass.services.async_call(
+        COVER_DOMAIN,
+        SERVICE_STOP_COVER_TILT,
+        {"entity_id": entity_id},
+        blocking=True,
+    )
+    mock_blind.stop_orientation.assert_awaited_once_with(wait_for_completion=False)
+
+
+async def test_blind_set_cover_tilt_position_inversion(
+    hass: HomeAssistant, mock_blind: AsyncMock
+) -> None:
+    """HA tilt position is inverted for device orientation."""
+
+    entity_id = "cover.test_blind"
+
+    await hass.services.async_call(
+        COVER_DOMAIN,
+        SERVICE_SET_COVER_TILT_POSITION,
+        {"entity_id": entity_id, ATTR_TILT_POSITION: 25},
+        blocking=True,
+    )
+
+    call = mock_blind.set_orientation.await_args
+    orientation_obj = call.kwargs.get("orientation")
+    assert orientation_obj is not None
+    assert orientation_obj.position_percent == 75
+    assert call.kwargs.get("wait_for_completion") is False
+
+
+async def test_blind_current_tilt_position(
+    hass: HomeAssistant, mock_blind: AsyncMock
+) -> None:
+    """Validate current_tilt_position attribute reflects inverted orientation."""
+
+    entity_id = "cover.test_blind"
+    mock_blind.orientation.position_percent = 10
+    await update_callback_entity(hass, mock_blind)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert state.attributes.get("current_tilt_position") == 90
+
+
+async def test_non_blind_has_no_tilt_position(
+    hass: HomeAssistant, mock_window: AsyncMock
+) -> None:
+    """Non-blind covers should not expose current_tilt_position attribute."""
+
+    entity_id = "cover.test_window"
+    await update_callback_entity(hass, mock_window)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert "current_tilt_position" not in state.attributes

tests/components/velux/test_light.py

@@ -4,20 +4,30 @@
 
 import pytest
 
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    DOMAIN as LIGHT_DOMAIN,
+    SERVICE_TURN_OFF,
+    SERVICE_TURN_ON,
+)
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 
+from . import update_callback_entity
+
 from tests.common import MockConfigEntry
 
+# Apply setup_integration fixture to all tests in this module
+pytestmark = pytest.mark.usefixtures("setup_integration")
+
 
 @pytest.fixture
 def platform() -> Platform:
     """Fixture to specify platform to test."""
     return Platform.LIGHT
 
 
-@pytest.mark.usefixtures("setup_integration")
 async def test_light_setup(
     hass: HomeAssistant,
     entity_registry: er.EntityRegistry,
@@ -46,7 +56,6 @@ async def test_light_setup(
 
 
 # This test is not light specific, it just uses the light platform to test the base entity class.
-@pytest.mark.usefixtures("setup_integration")
 async def test_entity_callbacks(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
@@ -70,3 +79,94 @@ async def test_entity_callbacks(
     # Callback must be unregistered with the same callable
     assert mock_light.unregister_device_updated_cb.call_count == 1
     assert mock_light.unregister_device_updated_cb.call_args[0][0] is cb
+
+
+async def test_light_brightness_and_is_on(
+    hass: HomeAssistant, mock_light: AsyncMock
+) -> None:
+    """Validate brightness mapping and on/off state from intensity."""
+
+    entity_id = f"light.{mock_light.name.lower().replace(' ', '_')}"
+
+    # Set initial intensity values
+    mock_light.intensity.intensity_percent = 20  # 20% "intensity" -> 80% brightness
+    mock_light.intensity.off = False
+    mock_light.intensity.known = True
+
+    # Trigger state write
+    await update_callback_entity(hass, mock_light)
+
+    state = hass.states.get(entity_id)
+    assert state is not None
+    # brightness = int((100 - 20) * 255 / 100) = int(204)
+    assert state.attributes.get("brightness") == 204
+    assert state.state == "on"
+
+    # Mark as off
+    mock_light.intensity.off = True
+    await update_callback_entity(hass, mock_light)
+    state = hass.states.get(entity_id)
+    assert state is not None
+    assert state.state == "off"
+
+
+async def test_light_turn_on_with_brightness_uses_set_intensity(
+    hass: HomeAssistant, mock_light: AsyncMock
+) -> None:
+    """Turning on with brightness calls set_intensity with inverted percent."""
+
+    entity_id = f"light.{mock_light.name.lower().replace(' ', '_')}"
+
+    # Call turn_on with brightness=51 (20% when normalized)
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        SERVICE_TURN_ON,
+        {"entity_id": entity_id, ATTR_BRIGHTNESS: 51},
+        blocking=True,
+    )
+
+    # set_intensity called once; turn_on should not be used in this path
+    assert mock_light.set_intensity.await_count == 1
+    assert mock_light.turn_on.await_count == 0
+
+    # Inspect the intensity argument (first positional)
+    args, kwargs = mock_light.set_intensity.await_args
+    intensity_obj = args[0]
+    # brightness 51 -> 20% normalized -> intensity_percent = 80
+    assert intensity_obj.intensity_percent == 80
+    assert kwargs.get("wait_for_completion") is True
+
+
+async def test_light_turn_on_without_brightness_calls_turn_on(
+    hass: HomeAssistant, mock_light: AsyncMock
+) -> None:
+    """Turning on without brightness uses device.turn_on."""
+
+    entity_id = f"light.{mock_light.name.lower().replace(' ', '_')}"
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        SERVICE_TURN_ON,
+        {"entity_id": entity_id},
+        blocking=True,
+    )
+
+    mock_light.turn_on.assert_awaited_once_with(wait_for_completion=True)
+    assert mock_light.set_intensity.await_count == 0
+
+
+async def test_light_turn_off_calls_turn_off(
+    hass: HomeAssistant, mock_light: AsyncMock
+) -> None:
+    """Turning off calls device.turn_off with wait_for_completion."""
+
+    entity_id = f"light.{mock_light.name.lower().replace(' ', '_')}"
+
+    await hass.services.async_call(
+        LIGHT_DOMAIN,
+        SERVICE_TURN_OFF,
+        {"entity_id": entity_id},
+        blocking=True,
+    )
+
+    mock_light.turn_off.assert_awaited_once_with(wait_for_completion=True)