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

Use parametrize in drop connect binary sensor tests (#107111)

Browse Source
This commit is contained in:
Joost Lekkerkerker 2024-01-08 10:38:44 +01:00 committed by GitHub
parent 14bf778c10
commit 82e0fc5f4e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 451 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

358
tests/components/drop_connect/snapshots/test_binary_sensor.ambr Normal file
View File

@ -0,0 +1,358 @@
# serializer version: 1
# name: test_sensors[hub][binary_sensor.hub_drop_1_c0ffee_leak_detected-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.hub_drop_1_c0ffee_leak_detected',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.MOISTURE: 'moisture'>,
'original_icon': 'mdi:pipe-leak',
'original_name': 'Leak detected',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'leak',
'unique_id': 'DROP-1_C0FFEE_255_leak',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[hub][binary_sensor.hub_drop_1_c0ffee_leak_detected-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'moisture',
'friendly_name': 'Hub DROP-1_C0FFEE Leak detected',
'icon': 'mdi:pipe-leak',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.hub_drop_1_c0ffee_leak_detected',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'off',
})
# ---
# name: test_sensors[hub][binary_sensor.hub_drop_1_c0ffee_notification_unread-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.hub_drop_1_c0ffee_notification_unread',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:bell-ring',
'original_name': 'Notification unread',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'pending_notification',
'unique_id': 'DROP-1_C0FFEE_255_pending_notification',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[hub][binary_sensor.hub_drop_1_c0ffee_notification_unread-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Hub DROP-1_C0FFEE Notification unread',
'icon': 'mdi:bell-ring',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.hub_drop_1_c0ffee_notification_unread',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[leak][binary_sensor.leak_detector_leak_detected-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.leak_detector_leak_detected',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.MOISTURE: 'moisture'>,
'original_icon': 'mdi:pipe-leak',
'original_name': 'Leak detected',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'leak',
'unique_id': 'DROP-1_C0FFEE_20_leak',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[leak][binary_sensor.leak_detector_leak_detected-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'moisture',
'friendly_name': 'Leak Detector Leak detected',
'icon': 'mdi:pipe-leak',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.leak_detector_leak_detected',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[protection_valve][binary_sensor.protection_valve_leak_detected-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.protection_valve_leak_detected',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.MOISTURE: 'moisture'>,
'original_icon': 'mdi:pipe-leak',
'original_name': 'Leak detected',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'leak',
'unique_id': 'DROP-1_C0FFEE_78_leak',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[protection_valve][binary_sensor.protection_valve_leak_detected-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'moisture',
'friendly_name': 'Protection Valve Leak detected',
'icon': 'mdi:pipe-leak',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.protection_valve_leak_detected',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[pump_controller][binary_sensor.pump_controller_leak_detected-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.pump_controller_leak_detected',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.MOISTURE: 'moisture'>,
'original_icon': 'mdi:pipe-leak',
'original_name': 'Leak detected',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'leak',
'unique_id': 'DROP-1_C0FFEE_83_leak',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[pump_controller][binary_sensor.pump_controller_leak_detected-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'moisture',
'friendly_name': 'Pump Controller Leak detected',
'icon': 'mdi:pipe-leak',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.pump_controller_leak_detected',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[pump_controller][binary_sensor.pump_controller_pump_status-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.pump_controller_pump_status',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:water-pump',
'original_name': 'Pump status',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'pump',
'unique_id': 'DROP-1_C0FFEE_83_pump',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[pump_controller][binary_sensor.pump_controller_pump_status-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Pump Controller Pump status',
'icon': 'mdi:water-pump',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.pump_controller_pump_status',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[ro_filter][binary_sensor.ro_filter_leak_detected-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.ro_filter_leak_detected',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': <BinarySensorDeviceClass.MOISTURE: 'moisture'>,
'original_icon': 'mdi:pipe-leak',
'original_name': 'Leak detected',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'leak',
'unique_id': 'DROP-1_C0FFEE_255_leak',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[ro_filter][binary_sensor.ro_filter_leak_detected-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'device_class': 'moisture',
'friendly_name': 'RO Filter Leak detected',
'icon': 'mdi:pipe-leak',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.ro_filter_leak_detected',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---
# name: test_sensors[softener][binary_sensor.softener_reserve_capacity_in_use-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': None,
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'binary_sensor',
'entity_category': None,
'entity_id': 'binary_sensor.softener_reserve_capacity_in_use',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'name': None,
'options': dict({
}),
'original_device_class': None,
'original_icon': 'mdi:water',
'original_name': 'Reserve capacity in use',
'platform': 'drop_connect',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'reserve_in_use',
'unique_id': 'DROP-1_C0FFEE_0_reserve_in_use',
'unit_of_measurement': None,
})
# ---
# name: test_sensors[softener][binary_sensor.softener_reserve_capacity_in_use-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'friendly_name': 'Softener Reserve capacity in use',
'icon': 'mdi:water',
}),
'context': <ANY>,
'entity_id': 'binary_sensor.softener_reserve_capacity_in_use',
'last_changed': <ANY>,
'last_updated': <ANY>,
'state': 'on',
})
# ---

246
tests/components/drop_connect/test_binary_sensor.py
View File

@ -1,7 +1,13 @@
"""Test DROP binary sensor entities."""
from homeassistant.const import STATE_OFF, STATE_ON
from unittest.mock import patch
import pytest
from syrupy import SnapshotAssertion
from homeassistant.const import STATE_OFF, Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from .common import (
TEST_DATA_HUB,
@ -19,9 +25,6 @@ from .common import (
TEST_DATA_RO_FILTER,
TEST_DATA_RO_FILTER_RESET,
TEST_DATA_RO_FILTER_TOPIC,
TEST_DATA_SALT,
TEST_DATA_SALT_RESET,
TEST_DATA_SALT_TOPIC,
TEST_DATA_SOFTENER,
TEST_DATA_SOFTENER_RESET,
TEST_DATA_SOFTENER_TOPIC,
@ -30,167 +33,104 @@ from .common import (
config_entry_protection_valve,
config_entry_pump_controller,
config_entry_ro_filter,
config_entry_salt,
config_entry_softener,
)
from tests.common import async_fire_mqtt_message
from tests.common import MockConfigEntry, async_fire_mqtt_message
from tests.typing import MqttMockHAClient
async def test_binary_sensors_hub(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
@pytest.mark.parametrize(
("config_entry", "topic", "reset", "data"),
[
(config_entry_hub(), TEST_DATA_HUB_TOPIC, TEST_DATA_HUB_RESET, TEST_DATA_HUB),
(
config_entry_leak(),
TEST_DATA_LEAK_TOPIC,
TEST_DATA_LEAK_RESET,
TEST_DATA_LEAK,
),
(
config_entry_softener(),
TEST_DATA_SOFTENER_TOPIC,
TEST_DATA_SOFTENER_RESET,
TEST_DATA_SOFTENER,
),
(
config_entry_protection_valve(),
TEST_DATA_PROTECTION_VALVE_TOPIC,
TEST_DATA_PROTECTION_VALVE_RESET,
TEST_DATA_PROTECTION_VALVE,
),
(
config_entry_pump_controller(),
TEST_DATA_PUMP_CONTROLLER_TOPIC,
TEST_DATA_PUMP_CONTROLLER_RESET,
TEST_DATA_PUMP_CONTROLLER,
),
(
config_entry_ro_filter(),
TEST_DATA_RO_FILTER_TOPIC,
TEST_DATA_RO_FILTER_RESET,
TEST_DATA_RO_FILTER,
),
],
ids=[
"hub",
"leak",
"softener",
"protection_valve",
"pump_controller",
"ro_filter",
],
)
async def test_sensors(
hass: HomeAssistant,
mqtt_mock: MqttMockHAClient,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
config_entry: MockConfigEntry,
topic: str,
reset: str,
data: str,
) -> None:
"""Test DROP binary sensors for hubs."""
entry = config_entry_hub()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
"""Test DROP sensors."""
config_entry.add_to_hass(hass)
pending_notifications_sensor_name = (
"binary_sensor.hub_drop_1_c0ffee_notification_unread"
with patch(
"homeassistant.components.drop_connect.PLATFORMS", [Platform.BINARY_SENSOR]
):
assert await hass.config_entries.async_setup(config_entry.entry_id)
await hass.async_block_till_done()
entity_entries = er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
assert hass.states.get(pending_notifications_sensor_name).state == STATE_OFF
leak_sensor_name = "binary_sensor.hub_drop_1_c0ffee_leak_detected"
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_HUB_TOPIC, TEST_DATA_HUB_RESET)
assert entity_entries
for entity_entry in entity_entries:
assert hass.states.get(entity_entry.entity_id).state == STATE_OFF
async_fire_mqtt_message(hass, topic, reset)
await hass.async_block_till_done()
assert hass.states.get(pending_notifications_sensor_name).state == STATE_OFF
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_HUB_TOPIC, TEST_DATA_HUB)
await hass.async_block_till_done()
assert hass.states.get(pending_notifications_sensor_name).state == STATE_ON
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async def test_binary_sensors_salt(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for salt sensors."""
entry = config_entry_salt()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
salt_sensor_name = "binary_sensor.salt_sensor_salt_low"
assert hass.states.get(salt_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_SALT_TOPIC, TEST_DATA_SALT_RESET)
await hass.async_block_till_done()
assert hass.states.get(salt_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_SALT_TOPIC, TEST_DATA_SALT)
await hass.async_block_till_done()
assert hass.states.get(salt_sensor_name).state == STATE_ON
async def test_binary_sensors_leak(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for leak detectors."""
entry = config_entry_leak()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
leak_sensor_name = "binary_sensor.leak_detector_leak_detected"
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_LEAK_TOPIC, TEST_DATA_LEAK_RESET)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_LEAK_TOPIC, TEST_DATA_LEAK)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_ON
async def test_binary_sensors_softener(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for softeners."""
entry = config_entry_softener()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
reserve_in_use_sensor_name = "binary_sensor.softener_reserve_capacity_in_use"
assert hass.states.get(reserve_in_use_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_SOFTENER_TOPIC, TEST_DATA_SOFTENER_RESET)
await hass.async_block_till_done()
assert hass.states.get(reserve_in_use_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_SOFTENER_TOPIC, TEST_DATA_SOFTENER)
await hass.async_block_till_done()
assert hass.states.get(reserve_in_use_sensor_name).state == STATE_ON
async def test_binary_sensors_protection_valve(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for protection valves."""
entry = config_entry_protection_valve()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
leak_sensor_name = "binary_sensor.protection_valve_leak_detected"
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(
hass, TEST_DATA_PROTECTION_VALVE_TOPIC, TEST_DATA_PROTECTION_VALVE_RESET
entity_entries = er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(
hass, TEST_DATA_PROTECTION_VALVE_TOPIC, TEST_DATA_PROTECTION_VALVE
assert entity_entries
for entity_entry in entity_entries:
assert hass.states.get(entity_entry.entity_id).state == STATE_OFF
async_fire_mqtt_message(hass, topic, data)
await hass.async_block_till_done()
entity_entries = er.async_entries_for_config_entry(
entity_registry, config_entry.entry_id
)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_ON
async def test_binary_sensors_pump_controller(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for pump controllers."""
entry = config_entry_pump_controller()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
leak_sensor_name = "binary_sensor.pump_controller_leak_detected"
assert hass.states.get(leak_sensor_name).state == STATE_OFF
pump_sensor_name = "binary_sensor.pump_controller_pump_status"
assert hass.states.get(pump_sensor_name).state == STATE_OFF
async_fire_mqtt_message(
hass, TEST_DATA_PUMP_CONTROLLER_TOPIC, TEST_DATA_PUMP_CONTROLLER_RESET
)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_OFF
assert hass.states.get(pump_sensor_name).state == STATE_OFF
async_fire_mqtt_message(
hass, TEST_DATA_PUMP_CONTROLLER_TOPIC, TEST_DATA_PUMP_CONTROLLER
)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_ON
assert hass.states.get(pump_sensor_name).state == STATE_ON
async def test_binary_sensors_ro_filter(
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP binary sensors for RO filters."""
entry = config_entry_ro_filter()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
leak_sensor_name = "binary_sensor.ro_filter_leak_detected"
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_RO_FILTER_TOPIC, TEST_DATA_RO_FILTER_RESET)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_OFF
async_fire_mqtt_message(hass, TEST_DATA_RO_FILTER_TOPIC, TEST_DATA_RO_FILTER)
await hass.async_block_till_done()
assert hass.states.get(leak_sensor_name).state == STATE_ON
assert entity_entries
for entity_entry in entity_entries:
assert entity_entry == snapshot(name=f"{entity_entry.entity_id}-entry")
assert hass.states.get(entity_entry.entity_id) == snapshot(
name=f"{entity_entry.entity_id}-state"
)