Files
core/tests/components/squeezebox/test_switch.py
peteS-UK 8623d96deb Squeezebox add alarms support - switch platform. Part 1 (#141055)
* initial

* remove dupe name definition

* snapshot update

* name def updates

* test update for new entity name

* remove attributes

* icon translations

* merge fixes

* Snapshot update post merge

* update to class initialisation

* move entity delete to coordinator

* remove some comments

* move known_alarms to coordinator

* test_switch update for syrupy change

* listener and sets

* check self.available

* remove refresh from conftest

* test update

* test tweak

* move listener to switch platform

* updates revew

* SWITCH_DOMAIN
2025-05-26 17:41:28 +02:00

136 lines
4.2 KiB
Python

"""Tests for the Squeezebox alarm switch platform."""
from datetime import timedelta
from unittest.mock import MagicMock
from freezegun.api import FrozenDateTimeFactory
from syrupy.assertion import SnapshotAssertion
from homeassistant.components.squeezebox.const import PLAYER_UPDATE_INTERVAL
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.const import CONF_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_registry import EntityRegistry
from .conftest import TEST_ALARM_ID
from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
async def test_entity_registry(
hass: HomeAssistant,
entity_registry: EntityRegistry,
mock_alarms_player: MagicMock,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
) -> None:
"""Test squeezebox media_player entity registered in the entity registry."""
await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id)
async def test_switch_state(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
freezer: FrozenDateTimeFactory,
) -> None:
"""Test the state of the switch."""
assert hass.states.get(f"switch.test_player_alarm_{TEST_ALARM_ID}").state == "on"
mock_alarms_player.alarms[0]["enabled"] = False
freezer.tick(timedelta(seconds=PLAYER_UPDATE_INTERVAL))
async_fire_time_changed(hass)
await hass.async_block_till_done()
assert hass.states.get(f"switch.test_player_alarm_{TEST_ALARM_ID}").state == "off"
async def test_switch_deleted(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
freezer: FrozenDateTimeFactory,
) -> None:
"""Test detecting switch deleted."""
assert hass.states.get(f"switch.test_player_alarm_{TEST_ALARM_ID}").state == "on"
mock_alarms_player.alarms = []
freezer.tick(timedelta(seconds=PLAYER_UPDATE_INTERVAL))
async_fire_time_changed(hass)
await hass.async_block_till_done()
assert hass.states.get(f"switch.test_player_alarm_{TEST_ALARM_ID}") is None
async def test_turn_on(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
) -> None:
"""Test turning on the switch."""
await hass.services.async_call(
SWITCH_DOMAIN,
SERVICE_TURN_ON,
{CONF_ENTITY_ID: f"switch.test_player_alarm_{TEST_ALARM_ID}"},
blocking=True,
)
mock_alarms_player.async_update_alarm.assert_called_once_with(
TEST_ALARM_ID, enabled=True
)
async def test_turn_off(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
) -> None:
"""Test turning on the switch."""
await hass.services.async_call(
SWITCH_DOMAIN,
SERVICE_TURN_OFF,
{CONF_ENTITY_ID: f"switch.test_player_alarm_{TEST_ALARM_ID}"},
blocking=True,
)
mock_alarms_player.async_update_alarm.assert_called_once_with(
TEST_ALARM_ID, enabled=False
)
async def test_alarms_enabled_state(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
freezer: FrozenDateTimeFactory,
) -> None:
"""Test the alarms enabled switch."""
assert hass.states.get("switch.test_player_alarms_enabled").state == "on"
mock_alarms_player.alarms_enabled = False
freezer.tick(timedelta(seconds=PLAYER_UPDATE_INTERVAL))
async_fire_time_changed(hass)
await hass.async_block_till_done()
assert hass.states.get("switch.test_player_alarms_enabled").state == "off"
async def test_alarms_enabled_turn_on(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
) -> None:
"""Test turning on the alarms enabled switch."""
await hass.services.async_call(
SWITCH_DOMAIN,
SERVICE_TURN_ON,
{CONF_ENTITY_ID: "switch.test_player_alarms_enabled"},
blocking=True,
)
mock_alarms_player.async_set_alarms_enabled.assert_called_once_with(True)
async def test_alarms_enabled_turn_off(
hass: HomeAssistant,
mock_alarms_player: MagicMock,
) -> None:
"""Test turning off the alarms enabled switch."""
await hass.services.async_call(
SWITCH_DOMAIN,
SERVICE_TURN_OFF,
{CONF_ENTITY_ID: "switch.test_player_alarms_enabled"},
blocking=True,
)
mock_alarms_player.async_set_alarms_enabled.assert_called_once_with(False)