diff --git a/tests/components/schlage/conftest.py b/tests/components/schlage/conftest.py index 334d3e62edaf..93f28769d63c 100644 --- a/tests/components/schlage/conftest.py +++ b/tests/components/schlage/conftest.py @@ -1,6 +1,6 @@ """Common fixtures for the Schlage tests.""" -from collections.abc import Generator +from collections.abc import Awaitable, Callable, Generator from typing import Any from unittest.mock import AsyncMock, Mock, create_autospec, patch @@ -32,20 +32,32 @@ def mock_config_entry() -> MockSchlageConfigEntry: @pytest.fixture async def mock_added_config_entry( + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], +) -> MockSchlageConfigEntry: + """Return a mock ConfigEntry that has been added to and set up in Home Assistant.""" + return await mock_add_config_entry() + + +@pytest.fixture +async def mock_add_config_entry( hass: HomeAssistant, mock_config_entry: MockSchlageConfigEntry, mock_pyschlage_auth: Mock, mock_schlage: Mock, mock_lock: Mock, -) -> MockSchlageConfigEntry: - """Mock ConfigEntry that's been added to HA.""" - mock_schlage.locks.return_value = [mock_lock] - mock_schlage.users.return_value = [] - mock_config_entry.add_to_hass(hass) - await hass.config_entries.async_setup(mock_config_entry.entry_id) - await hass.async_block_till_done() - assert DOMAIN in hass.config_entries.async_domains() - return mock_config_entry +) -> Callable[[], Awaitable[MockSchlageConfigEntry]]: + """Return a callable that adds and sets up the mock ConfigEntry in HA.""" + + async def callback() -> MockSchlageConfigEntry: + mock_schlage.locks.return_value = [mock_lock] + mock_schlage.users.return_value = [] + mock_config_entry.add_to_hass(hass) + await hass.config_entries.async_setup(mock_config_entry.entry_id) + await hass.async_block_till_done() + assert DOMAIN in hass.config_entries.async_domains() + return mock_config_entry + + return callback @pytest.fixture @@ -58,14 +70,14 @@ def mock_setup_entry() -> Generator[AsyncMock]: @pytest.fixture -def mock_schlage() -> Mock: +def mock_schlage() -> Generator[Mock]: """Mock pyschlage.Schlage.""" with patch("pyschlage.Schlage", autospec=True) as mock_schlage: yield mock_schlage.return_value @pytest.fixture -def mock_pyschlage_auth() -> Mock: +def mock_pyschlage_auth() -> Generator[Mock]: """Mock pyschlage.Auth.""" with patch("pyschlage.Auth", autospec=True) as mock_auth: mock_auth.return_value.user_id = "abc123" diff --git a/tests/components/schlage/snapshots/test_binary_sensor.ambr b/tests/components/schlage/snapshots/test_binary_sensor.ambr new file mode 100644 index 000000000000..b7794ddebd38 --- /dev/null +++ b/tests/components/schlage/snapshots/test_binary_sensor.ambr @@ -0,0 +1,52 @@ +# serializer version: 1 +# name: test_binary_sensor_attributes[binary_sensor.vault_door_keypad_disabled-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'binary_sensor', + 'entity_category': , + 'entity_id': 'binary_sensor.vault_door_keypad_disabled', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Keypad disabled', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Keypad disabled', + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'keypad_disabled', + 'unique_id': 'test_keypad_disabled', + 'unit_of_measurement': None, + }) +# --- +# name: test_binary_sensor_attributes[binary_sensor.vault_door_keypad_disabled-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'problem', + : 'Vault Door Keypad disabled', + }), + 'context': , + 'entity_id': 'binary_sensor.vault_door_keypad_disabled', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- diff --git a/tests/components/schlage/snapshots/test_lock.ambr b/tests/components/schlage/snapshots/test_lock.ambr new file mode 100644 index 000000000000..da61205399ea --- /dev/null +++ b/tests/components/schlage/snapshots/test_lock.ambr @@ -0,0 +1,53 @@ +# serializer version: 1 +# name: test_lock_attributes[lock.vault_door-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'lock', + 'entity_category': None, + 'entity_id': 'lock.vault_door', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': None, + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': 'test', + 'unit_of_measurement': None, + }) +# --- +# name: test_lock_attributes[lock.vault_door-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'thumbturn', + : 'Vault Door', + : , + }), + 'context': , + 'entity_id': 'lock.vault_door', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'unlocked', + }) +# --- diff --git a/tests/components/schlage/snapshots/test_select.ambr b/tests/components/schlage/snapshots/test_select.ambr new file mode 100644 index 000000000000..cd0f1e6e5700 --- /dev/null +++ b/tests/components/schlage/snapshots/test_select.ambr @@ -0,0 +1,72 @@ +# serializer version: 1 +# name: test_select_attributes[select.vault_door_auto_lock_time-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': dict({ + : list([ + '0', + '5', + '15', + '30', + '60', + '120', + '240', + '300', + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'select', + 'entity_category': , + 'entity_id': 'select.vault_door_auto_lock_time', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Auto-lock time', + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Auto-lock time', + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'auto_lock_time', + 'unique_id': 'test_auto_lock_time', + 'unit_of_measurement': None, + }) +# --- +# name: test_select_attributes[select.vault_door_auto_lock_time-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'Vault Door Auto-lock time', + : list([ + '0', + '5', + '15', + '30', + '60', + '120', + '240', + '300', + ]), + }), + 'context': , + 'entity_id': 'select.vault_door_auto_lock_time', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '15', + }) +# --- diff --git a/tests/components/schlage/snapshots/test_sensor.ambr b/tests/components/schlage/snapshots/test_sensor.ambr new file mode 100644 index 000000000000..ae8d301eaf28 --- /dev/null +++ b/tests/components/schlage/snapshots/test_sensor.ambr @@ -0,0 +1,56 @@ +# serializer version: 1 +# name: test_sensor_attributes[sensor.vault_door_battery-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': dict({ + : , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.vault_door_battery', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Battery', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Battery', + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': 'test_battery_level', + 'unit_of_measurement': '%', + }) +# --- +# name: test_sensor_attributes[sensor.vault_door_battery-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'battery', + : 'Vault Door Battery', + : , + : '%', + }), + 'context': , + 'entity_id': 'sensor.vault_door_battery', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '20', + }) +# --- diff --git a/tests/components/schlage/snapshots/test_switch.ambr b/tests/components/schlage/snapshots/test_switch.ambr new file mode 100644 index 000000000000..83ada67d660f --- /dev/null +++ b/tests/components/schlage/snapshots/test_switch.ambr @@ -0,0 +1,103 @@ +# serializer version: 1 +# name: test_switch_attributes[switch.vault_door_1_touch_locking-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'switch', + 'entity_category': , + 'entity_id': 'switch.vault_door_1_touch_locking', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': '1-Touch Locking', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': '1-Touch Locking', + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lock_and_leave', + 'unique_id': 'test_lock_and_leve', + 'unit_of_measurement': None, + }) +# --- +# name: test_switch_attributes[switch.vault_door_1_touch_locking-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'switch', + : 'Vault Door 1-Touch Locking', + }), + 'context': , + 'entity_id': 'switch.vault_door_1_touch_locking', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'on', + }) +# --- +# name: test_switch_attributes[switch.vault_door_keypress_beep-entry] + EntityRegistryEntrySnapshot({ + 'aliases': list([ + None, + ]), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'switch', + 'entity_category': , + 'entity_id': 'switch.vault_door_keypress_beep', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Keypress Beep', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Keypress Beep', + 'platform': 'schlage', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'beeper', + 'unique_id': 'test_beeper', + 'unit_of_measurement': None, + }) +# --- +# name: test_switch_attributes[switch.vault_door_keypress_beep-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + : 'switch', + : 'Vault Door Keypress Beep', + }), + 'context': , + 'entity_id': 'switch.vault_door_keypress_beep', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'on', + }) +# --- diff --git a/tests/components/schlage/test_binary_sensor.py b/tests/components/schlage/test_binary_sensor.py index a073097f755d..ef8fadfaa18f 100644 --- a/tests/components/schlage/test_binary_sensor.py +++ b/tests/components/schlage/test_binary_sensor.py @@ -1,65 +1,96 @@ """Test Schlage binary_sensor.""" -from datetime import timedelta -from unittest.mock import Mock +from collections.abc import Awaitable, Callable +from unittest.mock import Mock, patch from freezegun.api import FrozenDateTimeFactory from pyschlage.exceptions import UnknownError +from syrupy.assertion import SnapshotAssertion from homeassistant.components.binary_sensor import BinarySensorDeviceClass -from homeassistant.const import STATE_ON +from homeassistant.components.schlage.const import UPDATE_INTERVAL +from homeassistant.const import STATE_OFF, STATE_ON, Platform from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er from . import MockSchlageConfigEntry -from tests.common import async_fire_time_changed +from tests.common import async_fire_time_changed, snapshot_platform + + +async def test_binary_sensor_attributes( + hass: HomeAssistant, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, +) -> None: + """Test binary sensor attributes.""" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.BINARY_SENSOR]): + config_entry = await mock_add_config_entry() + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) async def test_keypad_disabled_binary_sensor( hass: HomeAssistant, - mock_schlage: Mock, mock_lock: Mock, - mock_added_config_entry: MockSchlageConfigEntry, - freezer: FrozenDateTimeFactory, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], ) -> None: """Test the keypad_disabled binary_sensor.""" mock_lock.keypad_disabled.reset_mock() mock_lock.keypad_disabled.return_value = True - - # Make the coordinator refresh data. - freezer.tick(timedelta(seconds=30)) - async_fire_time_changed(hass) - await hass.async_block_till_done(wait_background_tasks=True) + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.BINARY_SENSOR]): + await mock_add_config_entry() keypad = hass.states.get("binary_sensor.vault_door_keypad_disabled") assert keypad is not None assert keypad.state == STATE_ON assert keypad.attributes["device_class"] == BinarySensorDeviceClass.PROBLEM - mock_lock.keypad_disabled.assert_called_once_with([]) -async def test_keypad_disabled_binary_sensor_use_previous_logs_on_failure( +async def test_keypad_disabled_binary_sensor_logs_failure( hass: HomeAssistant, - mock_schlage: Mock, mock_lock: Mock, - mock_added_config_entry: MockSchlageConfigEntry, - freezer: FrozenDateTimeFactory, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], ) -> None: - """Test the keypad_disabled binary_sensor.""" + """Test the keypad_disabled binary_sensor when loading logs fails on initial setup.""" + mock_lock.keypad_disabled.reset_mock() + mock_lock.keypad_disabled.return_value = True + mock_lock.logs.side_effect = UnknownError("Cannot load logs") + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.BINARY_SENSOR]): + await mock_add_config_entry() + + keypad = hass.states.get("binary_sensor.vault_door_keypad_disabled") + assert keypad is not None + assert keypad.state == STATE_ON + assert keypad.attributes["device_class"] == BinarySensorDeviceClass.PROBLEM + mock_lock.keypad_disabled.assert_called_once_with([]) + + +async def test_keypad_disabled_uses_previous_logs_on_refresh_failure( + hass: HomeAssistant, + mock_lock: Mock, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + freezer: FrozenDateTimeFactory, +) -> None: + """Test that previous logs are used when a coordinator refresh fails to fetch logs.""" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.BINARY_SENSOR]): + await mock_add_config_entry() + + keypad = hass.states.get("binary_sensor.vault_door_keypad_disabled") + assert keypad is not None + assert keypad.state == STATE_OFF + mock_lock.keypad_disabled.reset_mock() mock_lock.keypad_disabled.return_value = True - mock_lock.logs.reset_mock() mock_lock.logs.side_effect = UnknownError("Cannot load logs") - # Make the coordinator refresh data. - freezer.tick(timedelta(seconds=30)) + freezer.tick(UPDATE_INTERVAL) async_fire_time_changed(hass) await hass.async_block_till_done(wait_background_tasks=True) keypad = hass.states.get("binary_sensor.vault_door_keypad_disabled") assert keypad is not None assert keypad.state == STATE_ON - assert keypad.attributes["device_class"] == BinarySensorDeviceClass.PROBLEM - + # Previous logs (empty list from initial refresh) are passed when fetch fails. mock_lock.keypad_disabled.assert_called_once_with([]) diff --git a/tests/components/schlage/test_lock.py b/tests/components/schlage/test_lock.py index 9756141005d6..f593ecd513aa 100644 --- a/tests/components/schlage/test_lock.py +++ b/tests/components/schlage/test_lock.py @@ -1,12 +1,13 @@ """Test schlage lock.""" -from datetime import timedelta -from unittest.mock import Mock +from collections.abc import Awaitable, Callable +from unittest.mock import Mock, patch from freezegun.api import FrozenDateTimeFactory from pyschlage.code import AccessCode from pyschlage.exceptions import Error as SchlageError import pytest +from syrupy.assertion import SnapshotAssertion import voluptuous as vol from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockState @@ -22,34 +23,42 @@ from homeassistant.const import ( SERVICE_LOCK, SERVICE_UNLOCK, STATE_UNAVAILABLE, + Platform, ) from homeassistant.core import HomeAssistant from homeassistant.exceptions import HomeAssistantError, ServiceValidationError +from homeassistant.helpers import entity_registry as er from . import MockSchlageConfigEntry -from tests.common import async_fire_time_changed +from tests.common import async_fire_time_changed, snapshot_platform async def test_lock_attributes( hass: HomeAssistant, - mock_added_config_entry: MockSchlageConfigEntry, - mock_schlage: Mock, - mock_lock: Mock, - freezer: FrozenDateTimeFactory, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, ) -> None: """Test lock attributes.""" - lock = hass.states.get("lock.vault_door") - assert lock is not None - assert lock.state == LockState.UNLOCKED - assert lock.attributes["changed_by"] == "thumbturn" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.LOCK]): + config_entry = await mock_add_config_entry() + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) + +async def test_lock_jammed( + hass: HomeAssistant, + mock_lock: Mock, + mock_added_config_entry: MockSchlageConfigEntry, + freezer: FrozenDateTimeFactory, +) -> None: + """Test lock jammed state.""" mock_lock.is_locked = False mock_lock.is_jammed = True - # Make the coordinator refresh data. - freezer.tick(timedelta(seconds=30)) + freezer.tick(UPDATE_INTERVAL) async_fire_time_changed(hass) await hass.async_block_till_done(wait_background_tasks=True) + lock = hass.states.get("lock.vault_door") assert lock is not None assert lock.state == LockState.JAMMED @@ -107,16 +116,13 @@ async def test_changed_by( """Test population of the changed_by attribute.""" mock_lock.last_changed_by.reset_mock() mock_lock.last_changed_by.return_value = "access code - foo" - - # Make the coordinator refresh data. - freezer.tick(timedelta(seconds=30)) + freezer.tick(UPDATE_INTERVAL) async_fire_time_changed(hass) await hass.async_block_till_done(wait_background_tasks=True) - mock_lock.last_changed_by.assert_called_with() - lock_device = hass.states.get("lock.vault_door") - assert lock_device is not None - assert lock_device.attributes.get("changed_by") == "access code - foo" + lock = hass.states.get("lock.vault_door") + assert lock is not None + assert lock.attributes["changed_by"] == "access code - foo" @pytest.mark.parametrize( diff --git a/tests/components/schlage/test_select.py b/tests/components/schlage/test_select.py index c18ceb0ec8e9..21e49580b333 100644 --- a/tests/components/schlage/test_select.py +++ b/tests/components/schlage/test_select.py @@ -1,8 +1,10 @@ """Test Schlage select.""" -from unittest.mock import Mock +from collections.abc import Awaitable, Callable +from unittest.mock import Mock, patch from pyschlage.lock import AUTO_LOCK_TIMES +from syrupy.assertion import SnapshotAssertion from homeassistant.components.schlage.const import DOMAIN from homeassistant.components.select import ( @@ -12,27 +14,43 @@ from homeassistant.components.select import ( ) from homeassistant.const import ATTR_ENTITY_ID, Platform from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er from homeassistant.helpers.translation import LOCALE_EN, async_get_translations from . import MockSchlageConfigEntry +from tests.common import snapshot_platform + + +async def test_select_attributes( + hass: HomeAssistant, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, +) -> None: + """Test select attributes.""" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.SELECT]): + config_entry = await mock_add_config_entry() + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) + async def test_select( hass: HomeAssistant, mock_lock: Mock, - mock_added_config_entry: MockSchlageConfigEntry, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], ) -> None: """Test the auto-lock time select entity.""" - entity_id = "select.vault_door_auto_lock_time" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.SELECT]): + await mock_add_config_entry() - select = hass.states.get(entity_id) + select = hass.states.get("select.vault_door_auto_lock_time") assert select is not None assert select.state == "15" await hass.services.async_call( SELECT_DOMAIN, SERVICE_SELECT_OPTION, - {ATTR_ENTITY_ID: entity_id, ATTR_OPTION: "30"}, + {ATTR_ENTITY_ID: select.entity_id, ATTR_OPTION: "30"}, blocking=True, ) mock_lock.set_auto_lock_time.assert_called_once_with(30) diff --git a/tests/components/schlage/test_sensor.py b/tests/components/schlage/test_sensor.py index 9a489f6ff73d..84a3745ffe2d 100644 --- a/tests/components/schlage/test_sensor.py +++ b/tests/components/schlage/test_sensor.py @@ -1,18 +1,26 @@ """Test schlage sensor.""" -from homeassistant.components.sensor import SensorDeviceClass -from homeassistant.const import PERCENTAGE +from collections.abc import Awaitable, Callable +from unittest.mock import patch + +from syrupy.assertion import SnapshotAssertion + +from homeassistant.const import Platform from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er from . import MockSchlageConfigEntry +from tests.common import snapshot_platform -async def test_battery_sensor( - hass: HomeAssistant, mock_added_config_entry: MockSchlageConfigEntry + +async def test_sensor_attributes( + hass: HomeAssistant, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, ) -> None: - """Test the battery sensor.""" - battery_sensor = hass.states.get("sensor.vault_door_battery") - assert battery_sensor is not None - assert battery_sensor.state == "20" - assert battery_sensor.attributes["unit_of_measurement"] == PERCENTAGE - assert battery_sensor.attributes["device_class"] == SensorDeviceClass.BATTERY + """Test sensor attributes.""" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.SENSOR]): + config_entry = await mock_add_config_entry() + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) diff --git a/tests/components/schlage/test_switch.py b/tests/components/schlage/test_switch.py index fc5acc4399f7..c50976b30cb9 100644 --- a/tests/components/schlage/test_switch.py +++ b/tests/components/schlage/test_switch.py @@ -1,13 +1,36 @@ """Test schlage switch.""" -from unittest.mock import Mock +from collections.abc import Awaitable, Callable +from unittest.mock import Mock, patch + +from syrupy.assertion import SnapshotAssertion from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN -from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON +from homeassistant.const import ( + ATTR_ENTITY_ID, + SERVICE_TURN_OFF, + SERVICE_TURN_ON, + Platform, +) from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er from . import MockSchlageConfigEntry +from tests.common import snapshot_platform + + +async def test_switch_attributes( + hass: HomeAssistant, + mock_add_config_entry: Callable[[], Awaitable[MockSchlageConfigEntry]], + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, +) -> None: + """Test switch attributes.""" + with patch("homeassistant.components.schlage.PLATFORMS", [Platform.SWITCH]): + config_entry = await mock_add_config_entry() + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id) + async def test_beeper_services( hass: HomeAssistant,