jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-13 08:17:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix sensor values for Power and Energy for Wolf Heatpumps (#139007)

Browse Source 
* Add sensor values for Power and Energy

* test

* test

* Sensor test

* Fix test

* fix test

* Fixing test coverage

* refactored

* WolfllinkSensorEntityDescriptions and updated tests

* fix test

* Add name_fn and test_sensor adoptions

* fix test coverage

* Revert "fix test coverage"

This reverts commit 2405751f5a9d0d5be67b78b39a510240a794a7e5.

* resolve requested changes and fix test

* Fix Snapshot

* clean up

* Fixed unknown state in snapshot test
This commit is contained in:
EnjoyingM 2025-03-15 19:56:45 +01:00 committed by GitHub
parent 2fd91e7f9c
commit c1c8deed0c
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 721 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
homeassistant/components/wolflink/sensor.py
View File

@ -2,19 +2,35 @@
from __future__ import annotations
from collections.abc import Callable
from dataclasses import dataclass
from wolf_comm.models import (
EnergyParameter,
HoursParameter,
ListItemParameter,
Parameter,
PercentageParameter,
PowerParameter,
Pressure,
SimpleParameter,
Temperature,
)
from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorEntityDescription,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import UnitOfPressure, UnitOfTemperature, UnitOfTime
from homeassistant.const import (
PERCENTAGE,
UnitOfEnergy,
UnitOfPower,
UnitOfPressure,
UnitOfTemperature,
UnitOfTime,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.device_registry import DeviceInfo
from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@ -23,31 +39,88 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import COORDINATOR, DEVICE_ID, DOMAIN, MANUFACTURER, PARAMETERS, STATES
def get_listitem_resolve_state(wolf_object, state):
"""Resolve list item state."""
resolved_state = [item for item in wolf_object.items if item.value == int(state)]
if resolved_state:
resolved_name = resolved_state[0].name
state = STATES.get(resolved_name, resolved_name)
return state
@dataclass(kw_only=True, frozen=True)
class WolflinkSensorEntityDescription(SensorEntityDescription):
"""Describes Wolflink sensor entity."""
value_fn: Callable[[Parameter, str], str | None] = lambda param, value: value
supported_fn: Callable[[Parameter], bool]
SENSOR_DESCRIPTIONS = [
WolflinkSensorEntityDescription(
key="temperature",
device_class=SensorDeviceClass.TEMPERATURE,
native_unit_of_measurement=UnitOfTemperature.CELSIUS,
supported_fn=lambda param: isinstance(param, Temperature),
),
WolflinkSensorEntityDescription(
key="pressure",
device_class=SensorDeviceClass.PRESSURE,
native_unit_of_measurement=UnitOfPressure.BAR,
supported_fn=lambda param: isinstance(param, Pressure),
),
WolflinkSensorEntityDescription(
key="energy",
device_class=SensorDeviceClass.ENERGY,
native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
supported_fn=lambda param: isinstance(param, EnergyParameter),
),
WolflinkSensorEntityDescription(
key="power",
device_class=SensorDeviceClass.POWER,
native_unit_of_measurement=UnitOfPower.KILO_WATT,
supported_fn=lambda param: isinstance(param, PowerParameter),
),
WolflinkSensorEntityDescription(
key="percentage",
native_unit_of_measurement=PERCENTAGE,
supported_fn=lambda param: isinstance(param, PercentageParameter),
),
WolflinkSensorEntityDescription(
key="list_item",
translation_key="state",
supported_fn=lambda param: isinstance(param, ListItemParameter),
value_fn=get_listitem_resolve_state,
),
WolflinkSensorEntityDescription(
key="hours",
icon="mdi:clock",
native_unit_of_measurement=UnitOfTime.HOURS,
supported_fn=lambda param: isinstance(param, HoursParameter),
),
WolflinkSensorEntityDescription(
key="default",
supported_fn=lambda param: isinstance(param, SimpleParameter),
),
]
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddConfigEntryEntitiesCallback,
) -> None:
"""Set up all entries for Wolf Platform."""
coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
parameters = hass.data[DOMAIN][config_entry.entry_id][PARAMETERS]
device_id = hass.data[DOMAIN][config_entry.entry_id][DEVICE_ID]
entities: list[WolfLinkSensor] = []
for parameter in parameters:
if isinstance(parameter, Temperature):
entities.append(WolfLinkTemperature(coordinator, parameter, device_id))
if isinstance(parameter, Pressure):
entities.append(WolfLinkPressure(coordinator, parameter, device_id))
if isinstance(parameter, PercentageParameter):
entities.append(WolfLinkPercentage(coordinator, parameter, device_id))
if isinstance(parameter, ListItemParameter):
entities.append(WolfLinkState(coordinator, parameter, device_id))
if isinstance(parameter, HoursParameter):
entities.append(WolfLinkHours(coordinator, parameter, device_id))
if isinstance(parameter, SimpleParameter):
entities.append(WolfLinkSensor(coordinator, parameter, device_id))
entities: list[WolfLinkSensor] = [
WolfLinkSensor(coordinator, parameter, device_id, description)
for parameter in parameters
for description in SENSOR_DESCRIPTIONS
if description.supported_fn(parameter)
]
async_add_entities(entities, True)
@ -55,9 +128,18 @@ async def async_setup_entry(
class WolfLinkSensor(CoordinatorEntity, SensorEntity):
"""Base class for all Wolf entities."""
def __init__(self, coordinator, wolf_object: Parameter, device_id) -> None:
entity_description: WolflinkSensorEntityDescription
def __init__(
self,
coordinator,
wolf_object: Parameter,
device_id: str,
description: WolflinkSensorEntityDescription,
) -> None:
"""Initialize."""
super().__init__(coordinator)
self.entity_description = description
self.wolf_object = wolf_object
self._attr_name = wolf_object.name
self._attr_unique_id = f"{device_id}:{wolf_object.parameter_id}"
@ -69,68 +151,26 @@ class WolfLinkSensor(CoordinatorEntity, SensorEntity):
)
@property
def native_value(self):
def native_value(self) -> str | None:
"""Return the state. Wolf Client is returning only changed values so we need to store old value here."""
if self.wolf_object.parameter_id in self.coordinator.data:
new_state = self.coordinator.data[self.wolf_object.parameter_id]
self.wolf_object.value_id = new_state[0]
self._state = new_state[1]
if (
isinstance(self.wolf_object, ListItemParameter)
and self._state is not None
):
self._state = self.entity_description.value_fn(
self.wolf_object, self._state
)
return self._state
@property
def extra_state_attributes(self):
def extra_state_attributes(self) -> dict[str, str | None]:
"""Return the state attributes."""
return {
"parameter_id": self.wolf_object.parameter_id,
"value_id": self.wolf_object.value_id,
"parent": self.wolf_object.parent,
}
class WolfLinkHours(WolfLinkSensor):
"""Class for hour based entities."""
_attr_icon = "mdi:clock"
_attr_native_unit_of_measurement = UnitOfTime.HOURS
class WolfLinkTemperature(WolfLinkSensor):
"""Class for temperature based entities."""
_attr_device_class = SensorDeviceClass.TEMPERATURE
_attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
class WolfLinkPressure(WolfLinkSensor):
"""Class for pressure based entities."""
_attr_device_class = SensorDeviceClass.PRESSURE
_attr_native_unit_of_measurement = UnitOfPressure.BAR
class WolfLinkPercentage(WolfLinkSensor):
"""Class for percentage based entities."""
@property
def native_unit_of_measurement(self):
"""Return the unit the value is expressed in."""
return self.wolf_object.unit
class WolfLinkState(WolfLinkSensor):
"""Class for entities which has defined list of state."""
_attr_translation_key = "state"
@property
def native_value(self):
"""Return the state converting with supported values."""
state = super().native_value
if state is not None:
resolved_state = [
item for item in self.wolf_object.items if item.value == int(state)
]
if resolved_state:
resolved_name = resolved_state[0].name
return STATES.get(resolved_name, resolved_name)
return state

13
tests/components/wolflink/__init__.py
View File

@ -1 +1,14 @@
"""Tests for the Wolf SmartSet Service integration."""
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
async def setup_integration(
hass: HomeAssistant, mock_config_entry: MockConfigEntry
) -> None:
"""Set up the wolflink integration for testing."""
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()

109
tests/components/wolflink/conftest.py Normal file
View File

@ -0,0 +1,109 @@
"""Fixtures for Wolflink integration tests."""
from __future__ import annotations
from collections.abc import Generator
from unittest.mock import MagicMock, patch
import pytest
from wolf_comm import (
EnergyParameter,
HoursParameter,
ListItem,
ListItemParameter,
PercentageParameter,
PowerParameter,
Pressure,
SimpleParameter,
Temperature,
Value,
)
from homeassistant.components.wolflink.const import (
DEVICE_GATEWAY,
DEVICE_ID,
DEVICE_NAME,
DOMAIN,
)
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from . import setup_integration
from tests.common import MockConfigEntry
@pytest.fixture
def mock_config_entry() -> MockConfigEntry:
"""Return the default mocked config entry."""
return MockConfigEntry(
title="Wolf SmartSet",
domain=DOMAIN,
data={
CONF_USERNAME: "test-username",
CONF_PASSWORD: "test-password",
DEVICE_NAME: "test-device",
DEVICE_GATEWAY: "5678",
DEVICE_ID: "1234",
},
unique_id="1234",
version=1,
minor_version=2,
)
@pytest.fixture
def mock_wolflink() -> Generator[MagicMock]:
"""Return a mocked wolflink client."""
with (
patch(
"homeassistant.components.wolflink.WolfClient", autospec=True
) as wolflink_mock,
patch(
"homeassistant.components.wolflink.config_flow.WolfClient",
new=wolflink_mock,
),
):
wolflink = wolflink_mock.return_value
wolflink.fetch_parameters.return_value = [
EnergyParameter(6002800000, "Energy Parameter", "Heating", 6005200000),
ListItemParameter(
8002800000,
"List Item Parameter",
"Heating",
[ListItem("0", "Aus"), ListItem("1", "Ein")],
8005200000,
),
PowerParameter(5002800000, "Power Parameter", "Heating", 5005200000),
Pressure(4002800000, "Pressure Parameter", "Heating", 4005200000),
Temperature(3002800000, "Temperature Parameter", "Solar", 3005200000),
PercentageParameter(
2002800000, "Percentage Parameter", "Solar", 2005200000
),
HoursParameter(7002800000, "Hours Parameter", "Heating", 7005200000),
SimpleParameter(1002800000, "Simple Parameter", "DHW", 1005200000),
]
wolflink.fetch_value.return_value = [
Value(6002800000, "183", 1),
Value(8002800000, "1", 1),
Value(5002800000, "50", 1),
Value(4002800000, "3", 1),
Value(3002800000, "65", 1),
Value(2002800000, "20", 1),
Value(7002800000, "10", 1),
Value(1002800000, "12", 1),
]
yield wolflink
@pytest.fixture
async def init_integration(
hass: HomeAssistant, mock_config_entry: MockConfigEntry, mock_wolflink: MagicMock
) -> MockConfigEntry:
"""Set up the Wolflink integration for testing."""
await setup_integration(hass, mock_config_entry)
return mock_config_entry

445
tests/components/wolflink/snapshots/test_sensor.ambr Normal file
View File

@ -0,0 +1,445 @@
# serializer version: 1
# name: test_device_entry
DeviceRegistryEntrySnapshot({
'area_id': None,
'config_entries': <ANY>,
'config_entries_subentries': <ANY>,
'configuration_url': 'https://www.wolf-smartset.com/',
'connections': set({
}),
'disabled_by': None,
'entry_type': None,
'hw_version': None,
'id': <ANY>,
'identifiers': set({
tuple(
'wolflink',
'1234',
),
}),
'is_new': False,
'labels': set({
}),
'manufacturer': 'WOLF GmbH',
'model': None,
'model_id': None,
'name': 'Wolf SmartSet',
'name_by_user': None,
'primary_config_entry': <ANY>,
'serial_number': None,
'suggested_area': None,
'sw_version': None,
'via_device_id': None,
})
# ---
# name: test_sensors[sensor.energy_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.energy_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
'original_name': 'Energy Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:6005200000',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
})
# ---
# name: test_sensors[sensor.energy_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'energy',
'friendly_name': 'Energy Parameter',
'parameter_id': 6005200000,
'parent': 'Heating',
'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
'value_id': 6002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.energy_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '183',
})
# ---
# name: test_sensors[sensor.hours_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.hours_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:clock',
'original_name': 'Hours Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:7005200000',
'unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
})
# ---
# name: test_sensors[sensor.hours_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Hours Parameter',
'icon': 'mdi:clock',
'parameter_id': 7005200000,
'parent': 'Heating',
'unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
'value_id': 7002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.hours_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '10',
})
# ---
# name: test_sensors[sensor.list_item_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.list_item_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'List Item Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'state',
'unique_id': '1234:8005200000',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[sensor.list_item_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'List Item Parameter',
'parameter_id': 8005200000,
'parent': 'Heating',
'value_id': 8002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.list_item_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'ein',
})
# ---
# name: test_sensors[sensor.percentage_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.percentage_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Percentage Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:2005200000',
'unit_of_measurement': '%',
})
# ---
# name: test_sensors[sensor.percentage_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Percentage Parameter',
'parameter_id': 2005200000,
'parent': 'Solar',
'unit_of_measurement': '%',
'value_id': 2002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.percentage_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '20',
})
# ---
# name: test_sensors[sensor.power_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.power_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
'original_name': 'Power Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:5005200000',
'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
})
# ---
# name: test_sensors[sensor.power_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'power',
'friendly_name': 'Power Parameter',
'parameter_id': 5005200000,
'parent': 'Heating',
'unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
'value_id': 5002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.power_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '50',
})
# ---
# name: test_sensors[sensor.pressure_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.pressure_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
'original_name': 'Pressure Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:4005200000',
'unit_of_measurement': <UnitOfPressure.BAR: 'bar'>,
})
# ---
# name: test_sensors[sensor.pressure_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'pressure',
'friendly_name': 'Pressure Parameter',
'parameter_id': 4005200000,
'parent': 'Heating',
'unit_of_measurement': <UnitOfPressure.BAR: 'bar'>,
'value_id': 4002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.pressure_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '3',
})
# ---
# name: test_sensors[sensor.simple_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.simple_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Simple Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:1005200000',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[sensor.simple_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Simple Parameter',
'parameter_id': 1005200000,
'parent': 'DHW',
'value_id': 1002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.simple_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '12',
})
# ---
# name: test_sensors[sensor.temperature_parameter-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'config_subentry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.temperature_parameter',
'has_entity_name': False,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
'original_name': 'Temperature Parameter',
'platform': 'wolflink',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '1234:3005200000',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
})
# ---
# name: test_sensors[sensor.temperature_parameter-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'temperature',
'friendly_name': 'Temperature Parameter',
'parameter_id': 3005200000,
'parent': 'Solar',
'unit_of_measurement': <UnitOfTemperature.CELSIUS: '°C'>,
'value_id': 3002800000,
}),
'context': <ANY>,
'entity_id': 'sensor.temperature_parameter',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '65',
})
# ---

45
tests/components/wolflink/test_sensor.py Normal file
View File

@ -0,0 +1,45 @@
"""Test the Wolf SmartSet Service Sensor platform."""
from unittest.mock import MagicMock
from syrupy import SnapshotAssertion
from homeassistant.const import Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import device_registry as dr, entity_registry as er
from . import setup_integration
from tests.common import MockConfigEntry, patch, snapshot_platform
async def test_device_entry(
hass: HomeAssistant,
mock_wolflink: MagicMock,
mock_config_entry: MockConfigEntry,
device_registry: dr.DeviceRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test device entry creation."""
mock_config_entry.add_to_hass(hass)
await hass.config_entries.async_setup(mock_config_entry.entry_id)
await hass.async_block_till_done()
device = device_registry.async_get_device({(mock_config_entry.domain, "1234")})
assert device == snapshot
async def test_sensors(
hass: HomeAssistant,
mock_wolflink: MagicMock,
mock_config_entry: MockConfigEntry,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
) -> None:
"""Test wolflink sensors."""
with patch("homeassistant.components.wolflink.PLATFORMS", [Platform.SENSOR]):
await setup_integration(hass, mock_config_entry)
await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)