Schlage: refactor tests to use snapshot_platform and factory fixture (#172639)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>

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"

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': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'binary_sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'binary_sensor.vault_door_keypad_disabled',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Keypad disabled',
+    'options': dict({
+    }),
+    'original_device_class': <BinarySensorDeviceClass.PROBLEM: 'problem'>,
+    '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({
+      <EntityStateAttribute.DEVICE_CLASS: 'device_class'>: 'problem',
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door Keypad disabled',
+    }),
+    'context': <ANY>,
+    'entity_id': 'binary_sensor.vault_door_keypad_disabled',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'off',
+  })
+# ---

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': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'lock',
+    'entity_category': None,
+    'entity_id': 'lock.vault_door',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    '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({
+      <LockEntityStateAttribute.CHANGED_BY: 'changed_by'>: 'thumbturn',
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door',
+      <EntityStateAttribute.SUPPORTED_FEATURES: 'supported_features'>: <LockEntityFeature: 0>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'lock.vault_door',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'unlocked',
+  })
+# ---

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({
+      <SelectEntityCapabilityAttribute.OPTIONS: 'options'>: list([
+        '0',
+        '5',
+        '15',
+        '30',
+        '60',
+        '120',
+        '240',
+        '300',
+      ]),
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'select',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'select.vault_door_auto_lock_time',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    '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({
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door Auto-lock time',
+      <SelectEntityCapabilityAttribute.OPTIONS: 'options'>: list([
+        '0',
+        '5',
+        '15',
+        '30',
+        '60',
+        '120',
+        '240',
+        '300',
+      ]),
+    }),
+    'context': <ANY>,
+    'entity_id': 'select.vault_door_auto_lock_time',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '15',
+  })
+# ---

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({
+      <SensorEntityCapabilityAttribute.STATE_CLASS: 'state_class'>: <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': <EntityCategory.DIAGNOSTIC: 'diagnostic'>,
+    'entity_id': 'sensor.vault_door_battery',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Battery',
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.BATTERY: 'battery'>,
+    '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({
+      <EntityStateAttribute.DEVICE_CLASS: 'device_class'>: 'battery',
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door Battery',
+      <SensorEntityCapabilityAttribute.STATE_CLASS: 'state_class'>: <SensorStateClass.MEASUREMENT: 'measurement'>,
+      <EntityStateAttribute.UNIT_OF_MEASUREMENT: 'unit_of_measurement'>: '%',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.vault_door_battery',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '20',
+  })
+# ---

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': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'switch',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'switch.vault_door_1_touch_locking',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': '1-Touch Locking',
+    'options': dict({
+    }),
+    'original_device_class': <SwitchDeviceClass.SWITCH: 'switch'>,
+    '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({
+      <EntityStateAttribute.DEVICE_CLASS: 'device_class'>: 'switch',
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door 1-Touch Locking',
+    }),
+    'context': <ANY>,
+    'entity_id': 'switch.vault_door_1_touch_locking',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'on',
+  })
+# ---
+# name: test_switch_attributes[switch.vault_door_keypress_beep-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': list([
+      None,
+    ]),
+    'area_id': None,
+    'capabilities': None,
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'switch',
+    'entity_category': <EntityCategory.CONFIG: 'config'>,
+    'entity_id': 'switch.vault_door_keypress_beep',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Keypress Beep',
+    'options': dict({
+    }),
+    'original_device_class': <SwitchDeviceClass.SWITCH: 'switch'>,
+    '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({
+      <EntityStateAttribute.DEVICE_CLASS: 'device_class'>: 'switch',
+      <EntityStateAttribute.FRIENDLY_NAME: 'friendly_name'>: 'Vault Door Keypress Beep',
+    }),
+    'context': <ANY>,
+    'entity_id': 'switch.vault_door_keypress_beep',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': 'on',
+  })
+# ---

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([])

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(

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)

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)

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,