From 68cc6df3e0e49e85bf1d2779424910c8fcfc2df2 Mon Sep 17 00:00:00 2001 From: Joost Lekkerkerker Date: Fri, 3 Apr 2026 15:13:17 +0200 Subject: [PATCH] Make sure we take all Zinvolt battery units in account (#167294) --- .../components/zinvolt/binary_sensor.py | 21 +- .../components/zinvolt/coordinator.py | 46 ++- homeassistant/components/zinvolt/entity.py | 58 ++- tests/components/zinvolt/conftest.py | 5 +- tests/components/zinvolt/fixtures/units.json | 48 +++ .../zinvolt/snapshots/test_binary_sensor.ambr | 357 ++++++++++++++++++ .../zinvolt/snapshots/test_diagnostics.ambr | 39 +- .../zinvolt/snapshots/test_init.ambr | 35 +- tests/components/zinvolt/test_init.py | 7 +- 9 files changed, 579 insertions(+), 37 deletions(-) create mode 100644 tests/components/zinvolt/fixtures/units.json diff --git a/homeassistant/components/zinvolt/binary_sensor.py b/homeassistant/components/zinvolt/binary_sensor.py index b34fada6ee4e..52e44ec7c77e 100644 --- a/homeassistant/components/zinvolt/binary_sensor.py +++ b/homeassistant/components/zinvolt/binary_sensor.py @@ -13,7 +13,7 @@ from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback from .coordinator import ZinvoltConfigEntry, ZinvoltData, ZinvoltDeviceCoordinator -from .entity import ZinvoltEntity +from .entity import ZinvoltEntity, ZinvoltUnitEntity POINT_ENTITIES = { "communication": BinarySensorDeviceClass.PROBLEM, @@ -57,9 +57,10 @@ async def async_setup_entry( for coordinator in entry.runtime_data.values() ] entities.extend( - ZinvoltPointBinarySensor(coordinator, point) + ZinvoltPointBinarySensor(coordinator, battery.serial_number, point) for coordinator in entry.runtime_data.values() - for point in coordinator.data.points + for battery in coordinator.battery_units.values() + for point in coordinator.data.batteries[battery.serial_number].points if point in POINT_ENTITIES ) async_add_entities(entities) @@ -88,25 +89,27 @@ class ZinvoltBatteryStateBinarySensor(ZinvoltEntity, BinarySensorEntity): return self.entity_description.is_on_fn(self.coordinator.data) -class ZinvoltPointBinarySensor(ZinvoltEntity, BinarySensorEntity): +class ZinvoltPointBinarySensor(ZinvoltUnitEntity, BinarySensorEntity): """Zinvolt battery state binary sensor.""" _attr_entity_category = EntityCategory.DIAGNOSTIC - def __init__(self, coordinator: ZinvoltDeviceCoordinator, point: str) -> None: + def __init__( + self, coordinator: ZinvoltDeviceCoordinator, unit_serial_number: str, point: str + ) -> None: """Initialize the binary sensor.""" - super().__init__(coordinator) + super().__init__(coordinator, unit_serial_number) self.point = point self._attr_translation_key = point self._attr_device_class = POINT_ENTITIES[point] - self._attr_unique_id = f"{coordinator.data.battery.serial_number}.{point}" + self._attr_unique_id = f"{self.serial_number}.{point}" @property def available(self) -> bool: """Return the availability of the binary sensor.""" - return super().available and self.point in self.coordinator.data.points + return super().available and self.point in self.battery.points @property def is_on(self) -> bool: """Return the state of the binary sensor.""" - return not self.coordinator.data.points[self.point] + return not self.battery.points[self.point] diff --git a/homeassistant/components/zinvolt/coordinator.py b/homeassistant/components/zinvolt/coordinator.py index 862a4cf87186..c2471f162da3 100644 --- a/homeassistant/components/zinvolt/coordinator.py +++ b/homeassistant/components/zinvolt/coordinator.py @@ -6,7 +6,7 @@ import logging from zinvolt import ZinvoltClient from zinvolt.exceptions import ZinvoltError -from zinvolt.models import Battery, BatteryState +from zinvolt.models import Battery, BatteryState, Unit, UnitType from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant @@ -24,6 +24,13 @@ class ZinvoltData: """Data for the Zinvolt integration.""" battery: BatteryState + batteries: dict[str, BatteryData] + + +@dataclass +class BatteryData: + """Data per battery unit.""" + sw_version: str model: str points: dict[str, bool] @@ -32,6 +39,8 @@ class ZinvoltData: class ZinvoltDeviceCoordinator(DataUpdateCoordinator[ZinvoltData]): """Class for Zinvolt devices.""" + battery_units: dict[str, Unit] + def __init__( self, hass: HomeAssistant, @@ -50,15 +59,30 @@ class ZinvoltDeviceCoordinator(DataUpdateCoordinator[ZinvoltData]): self.battery = battery self.client = client + async def _async_setup(self) -> None: + """Set up the Zinvolt integration.""" + try: + units = await self.client.get_units(self.battery.identifier) + except ZinvoltError as err: + raise UpdateFailed( + translation_key="update_failed", translation_domain=DOMAIN + ) from err + self.battery_units = { + unit.serial_number: unit for unit in units if unit.type is UnitType.BATTERY + } + async def _async_update_data(self) -> ZinvoltData: """Update data from Zinvolt.""" try: battery_state = await self.client.get_battery_status( self.battery.identifier ) - battery_unit = await self.client.get_battery_unit( - self.battery.identifier, self.battery.serial_number - ) + battery_units = { + unit_serial_number: await self.client.get_battery_unit( + self.battery.identifier, unit_serial_number + ) + for unit_serial_number in self.battery_units + } except ZinvoltError as err: raise UpdateFailed( translation_key="update_failed", @@ -66,7 +90,15 @@ class ZinvoltDeviceCoordinator(DataUpdateCoordinator[ZinvoltData]): ) from err return ZinvoltData( battery_state, - battery_unit.version.current_version, - battery_unit.battery_model, - {point.point.lower(): point.normal for point in battery_unit.points}, + { + serial_number: BatteryData( + battery_unit.version.current_version, + battery_unit.battery_model, + { + point.point.lower(): point.normal + for point in battery_unit.points + }, + ) + for serial_number, battery_unit in battery_units.items() + }, ) diff --git a/homeassistant/components/zinvolt/entity.py b/homeassistant/components/zinvolt/entity.py index a9e9a2c89df1..932e18fb0957 100644 --- a/homeassistant/components/zinvolt/entity.py +++ b/homeassistant/components/zinvolt/entity.py @@ -1,10 +1,13 @@ """Base entity for Zinvolt integration.""" +from zinvolt.models import Unit + +from homeassistant.const import ATTR_VIA_DEVICE from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.update_coordinator import CoordinatorEntity from .const import DOMAIN -from .coordinator import ZinvoltDeviceCoordinator +from .coordinator import BatteryData, ZinvoltDeviceCoordinator class ZinvoltEntity(CoordinatorEntity[ZinvoltDeviceCoordinator]): @@ -20,6 +23,55 @@ class ZinvoltEntity(CoordinatorEntity[ZinvoltDeviceCoordinator]): manufacturer="Zinvolt", name=coordinator.battery.name, serial_number=coordinator.data.battery.serial_number, - model_id=coordinator.data.model, - sw_version=coordinator.data.sw_version, + ) + + +class ZinvoltUnitEntity(ZinvoltEntity): + """Base entity for Zinvolt units.""" + + def __init__( + self, coordinator: ZinvoltDeviceCoordinator, unit_serial_number: str + ) -> None: + """Initialize the entity.""" + super().__init__(coordinator) + self.unit_serial_number = unit_serial_number + is_main_device = ( + list(coordinator.battery_units).index(self.unit_serial_number) == 0 + ) + self.serial_number = ( + coordinator.data.battery.serial_number + if is_main_device + else self.battery_unit.serial_number + ) + name = coordinator.battery.name if is_main_device else self.battery_unit.name + self._attr_device_info = DeviceInfo( + identifiers={(DOMAIN, self.serial_number)}, + manufacturer="Zinvolt", + name=name, + serial_number=self.serial_number, + sw_version=self.battery_unit.version.current_version, + model_id=self.battery.model, + ) + if not is_main_device: + self._attr_device_info[ATTR_VIA_DEVICE] = ( + DOMAIN, + coordinator.data.battery.serial_number, + ) + + @property + def battery(self) -> BatteryData: + """Return the battery data.""" + return self.coordinator.data.batteries[self.unit_serial_number] + + @property + def battery_unit(self) -> Unit: + """Return the battery unit.""" + return self.coordinator.battery_units[self.unit_serial_number] + + @property + def available(self) -> bool: + """Return if the entity is available.""" + return ( + super().available + and self.unit_serial_number in self.coordinator.data.batteries ) diff --git a/tests/components/zinvolt/conftest.py b/tests/components/zinvolt/conftest.py index a01a62d80519..5ed74c96bc09 100644 --- a/tests/components/zinvolt/conftest.py +++ b/tests/components/zinvolt/conftest.py @@ -4,7 +4,7 @@ from collections.abc import Generator from unittest.mock import AsyncMock, patch import pytest -from zinvolt.models import BatteryListResponse, BatteryState, BatteryUnit +from zinvolt.models import BatteryListResponse, BatteryState, BatteryUnit, UnitsResponse from homeassistant.components.zinvolt.const import DOMAIN from homeassistant.const import CONF_ACCESS_TOKEN @@ -57,4 +57,7 @@ def mock_zinvolt_client() -> Generator[AsyncMock]: client.get_battery_unit.return_value = BatteryUnit.from_json( load_fixture("battery_unit.json", DOMAIN) ) + client.get_units.return_value = UnitsResponse.from_json( + load_fixture("units.json", DOMAIN) + ).units yield client diff --git a/tests/components/zinvolt/fixtures/units.json b/tests/components/zinvolt/fixtures/units.json new file mode 100644 index 000000000000..aa709b024bf3 --- /dev/null +++ b/tests/components/zinvolt/fixtures/units.json @@ -0,0 +1,48 @@ +{ + "units": [ + { + "usn": "INV001", + "name": "Inverter", + "type": "INVERTER", + "abnormalAmount": 0, + "resettable": false, + "version": { + "currentVersion": "V1.032", + "status": "NO_UPDATE" + } + }, + { + "usn": "ems", + "name": "EMS", + "type": "EMS", + "abnormalAmount": 0, + "resettable": false, + "version": { + "currentVersion": "V1.01.45E", + "status": "NO_UPDATE" + } + }, + { + "usn": "BAT001", + "name": "Battery - 1", + "type": "BATTERY", + "abnormalAmount": 0, + "resettable": false, + "version": { + "currentVersion": "V1.20", + "status": "NO_UPDATE" + } + }, + { + "usn": "BAT002", + "name": "Battery - 2", + "type": "BATTERY", + "abnormalAmount": 0, + "resettable": false, + "version": { + "currentVersion": "V1.20", + "status": "NO_UPDATE" + } + } + ] +} diff --git a/tests/components/zinvolt/snapshots/test_binary_sensor.ambr b/tests/components/zinvolt/snapshots/test_binary_sensor.ambr index 27de2b38003c..60166ab29552 100644 --- a/tests/components/zinvolt/snapshots/test_binary_sensor.ambr +++ b/tests/components/zinvolt/snapshots/test_binary_sensor.ambr @@ -1,4 +1,361 @@ # serializer version: 1 +# name: test_all_entities[binary_sensor.battery_2_charge-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.battery_2_charge', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Charge', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Charge', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'charge', + 'unique_id': 'BAT002.charge', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_charge-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Charge', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_charge', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_communication-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.battery_2_communication', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Communication', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Communication', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'communication', + 'unique_id': 'BAT002.communication', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_communication-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Communication', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_communication', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_current-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.battery_2_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Current', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Current', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'current', + 'unique_id': 'BAT002.current', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_current-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Current', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_current', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_discharge-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.battery_2_discharge', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Discharge', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Discharge', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'discharge', + 'unique_id': 'BAT002.discharge', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_discharge-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Discharge', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_discharge', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_heat-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.battery_2_heat', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Heat', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Heat', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'temperature', + 'unique_id': 'BAT002.temperature', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_heat-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'heat', + 'friendly_name': 'Battery - 2 Heat', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_heat', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_other_problems-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.battery_2_other_problems', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Other problems', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Other problems', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'other', + 'unique_id': 'BAT002.other', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_other_problems-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Other problems', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_other_problems', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_voltage-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.battery_2_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'object_id_base': 'Voltage', + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Voltage', + 'platform': 'zinvolt', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'voltage', + 'unique_id': 'BAT002.voltage', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[binary_sensor.battery_2_voltage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'problem', + 'friendly_name': 'Battery - 2 Voltage', + }), + 'context': , + 'entity_id': 'binary_sensor.battery_2_voltage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'off', + }) +# --- # name: test_all_entities[binary_sensor.zinvolt_batterij_charge-entry] EntityRegistryEntrySnapshot({ 'aliases': list([ diff --git a/tests/components/zinvolt/snapshots/test_diagnostics.ambr b/tests/components/zinvolt/snapshots/test_diagnostics.ambr index dd97e06b4084..215205463528 100644 --- a/tests/components/zinvolt/snapshots/test_diagnostics.ambr +++ b/tests/components/zinvolt/snapshots/test_diagnostics.ambr @@ -4,6 +4,34 @@ 'coordinators': list([ dict({ 'a125ef17-6bdf-45ad-b106-ce54e95e4634': dict({ + 'batteries': dict({ + 'BAT001': dict({ + 'model': 'ZVS4000', + 'points': dict({ + 'charge': True, + 'communication': True, + 'current': True, + 'discharge': True, + 'other': True, + 'temperature': True, + 'voltage': True, + }), + 'sw_version': 'V1.02-V0.00.000', + }), + 'BAT002': dict({ + 'model': 'ZVS4000', + 'points': dict({ + 'charge': True, + 'communication': True, + 'current': True, + 'discharge': True, + 'other': True, + 'temperature': True, + 'voltage': True, + }), + 'sw_version': 'V1.02-V0.00.000', + }), + }), 'battery': dict({ 'current_power': dict({ 'is_dormant': False, @@ -29,17 +57,6 @@ 'serial_number': 'ZVG011025120088', 'smart_mode': 'CHARGED', }), - 'model': 'ZVS4000', - 'points': dict({ - 'charge': True, - 'communication': True, - 'current': True, - 'discharge': True, - 'other': True, - 'temperature': True, - 'voltage': True, - }), - 'sw_version': 'V1.02-V0.00.000', }), }), ]), diff --git a/tests/components/zinvolt/snapshots/test_init.ambr b/tests/components/zinvolt/snapshots/test_init.ambr index e6ec512fa794..657cb27c219b 100644 --- a/tests/components/zinvolt/snapshots/test_init.ambr +++ b/tests/components/zinvolt/snapshots/test_init.ambr @@ -1,5 +1,36 @@ # serializer version: 1 -# name: test_device +# name: test_device[BAT002] + DeviceRegistryEntrySnapshot({ + 'area_id': None, + 'config_entries': , + 'config_entries_subentries': , + 'configuration_url': None, + 'connections': set({ + }), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'id': , + 'identifiers': set({ + tuple( + 'zinvolt', + 'BAT002', + ), + }), + 'labels': set({ + }), + 'manufacturer': 'Zinvolt', + 'model': None, + 'model_id': 'ZVS4000', + 'name': 'Battery - 2', + 'name_by_user': None, + 'primary_config_entry': , + 'serial_number': 'BAT002', + 'sw_version': 'V1.20', + 'via_device_id': , + }) +# --- +# name: test_device[ZVG011025120088] DeviceRegistryEntrySnapshot({ 'area_id': None, 'config_entries': , @@ -26,7 +57,7 @@ 'name_by_user': None, 'primary_config_entry': , 'serial_number': 'ZVG011025120088', - 'sw_version': 'V1.02-V0.00.000', + 'sw_version': 'V1.20', 'via_device_id': None, }) # --- diff --git a/tests/components/zinvolt/test_init.py b/tests/components/zinvolt/test_init.py index 5c755d987bd7..e197458ea961 100644 --- a/tests/components/zinvolt/test_init.py +++ b/tests/components/zinvolt/test_init.py @@ -4,7 +4,6 @@ from unittest.mock import AsyncMock from syrupy.assertion import SnapshotAssertion -from homeassistant.components.zinvolt.const import DOMAIN from homeassistant.core import HomeAssistant from homeassistant.helpers import device_registry as dr @@ -22,6 +21,6 @@ async def test_device( ) -> None: """Test the Zinvolt device.""" await setup_integration(hass, mock_config_entry) - device = device_registry.async_get_device({(DOMAIN, "ZVG011025120088")}) - assert device - assert device == snapshot + devices = device_registry.devices + for device in devices.values(): + assert device == snapshot(name=list(device.identifiers)[0][1])