Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor drop sensor tests (#106965) 

* Refactor drop sensor tests

* Setup the config entry instead of the component
pull/107090/head
Jan Bouwhuis 2024-01-04 10:43:04 +01:00 committed by GitHub
parent 26055ee636
commit 5508bb3ef9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 261 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

167
tests/components/drop_connect/common.py
View File

@ -1,5 +1,20 @@
"""Define common test values."""
from homeassistant.components.drop_connect.const import (
CONF_COMMAND_TOPIC,
CONF_DATA_TOPIC,
CONF_DEVICE_DESC,
CONF_DEVICE_ID,
CONF_DEVICE_NAME,
CONF_DEVICE_OWNER_ID,
CONF_DEVICE_TYPE,
CONF_HUB_ID,
DOMAIN,
)
from homeassistant.config_entries import ConfigEntry
from tests.common import MockConfigEntry
TEST_DATA_HUB_TOPIC = "drop_connect/DROP-1_C0FFEE/255"
TEST_DATA_HUB = (
'{"curFlow":5.77,"peakFlow":13.8,"usedToday":232.77,"avgUsed":76,"psi":62.2,"psiLow":61,"psiHigh":62,'
@ -49,3 +64,155 @@ TEST_DATA_RO_FILTER = (
TEST_DATA_RO_FILTER_RESET = (
'{"leak":0,"tdsIn":0,"tdsOut":0,"cart1":0,"cart2":0,"cart3":0}'
)
def config_entry_hub() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_255",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/255/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/255/#",
CONF_DEVICE_DESC: "Hub",
CONF_DEVICE_ID: 255,
CONF_DEVICE_NAME: "Hub DROP-1_C0FFEE",
CONF_DEVICE_TYPE: "hub",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_salt() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_8",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/8/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/8/#",
CONF_DEVICE_DESC: "Salt Sensor",
CONF_DEVICE_ID: 8,
CONF_DEVICE_NAME: "Salt Sensor",
CONF_DEVICE_TYPE: "salt",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_leak() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_20",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/20/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/20/#",
CONF_DEVICE_DESC: "Leak Detector",
CONF_DEVICE_ID: 20,
CONF_DEVICE_NAME: "Leak Detector",
CONF_DEVICE_TYPE: "leak",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_softener() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_0",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/0/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/0/#",
CONF_DEVICE_DESC: "Softener",
CONF_DEVICE_ID: 0,
CONF_DEVICE_NAME: "Softener",
CONF_DEVICE_TYPE: "soft",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_filter() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_4",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/4/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/4/#",
CONF_DEVICE_DESC: "Filter",
CONF_DEVICE_ID: 4,
CONF_DEVICE_NAME: "Filter",
CONF_DEVICE_TYPE: "filt",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_protection_valve() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_78",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/78/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/78/#",
CONF_DEVICE_DESC: "Protection Valve",
CONF_DEVICE_ID: 78,
CONF_DEVICE_NAME: "Protection Valve",
CONF_DEVICE_TYPE: "pv",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_pump_controller() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_83",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/83/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/83/#",
CONF_DEVICE_DESC: "Pump Controller",
CONF_DEVICE_ID: 83,
CONF_DEVICE_NAME: "Pump Controller",
CONF_DEVICE_TYPE: "pc",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)
def config_entry_ro_filter() -> ConfigEntry:
"""Config entry version 1 fixture."""
return MockConfigEntry(
domain=DOMAIN,
unique_id="DROP-1_C0FFEE_255",
data={
CONF_COMMAND_TOPIC: "drop_connect/DROP-1_C0FFEE/95/cmd",
CONF_DATA_TOPIC: "drop_connect/DROP-1_C0FFEE/95/#",
CONF_DEVICE_DESC: "RO Filter",
CONF_DEVICE_ID: 95,
CONF_DEVICE_NAME: "RO Filter",
CONF_DEVICE_TYPE: "ro",
CONF_HUB_ID: "DROP-1_C0FFEE",
CONF_DEVICE_OWNER_ID: "DROP-1_C0FFEE_255",
},
version=1,
)

188
tests/components/drop_connect/test_sensor.py
View File

@ -1,8 +1,7 @@
"""Test DROP sensor entities."""
from homeassistant.components.drop_connect.const import DOMAIN
from homeassistant.const import STATE_UNKNOWN
from homeassistant.core import HomeAssistant
from homeassistant.setup import async_setup_component
from .common import (
TEST_DATA_FILTER,
@ -26,36 +25,41 @@ from .common import (
TEST_DATA_SOFTENER,
TEST_DATA_SOFTENER_RESET,
TEST_DATA_SOFTENER_TOPIC,
config_entry_filter,
config_entry_hub,
config_entry_leak,
config_entry_protection_valve,
config_entry_pump_controller,
config_entry_ro_filter,
config_entry_softener,
)
from tests.common import async_fire_mqtt_message
from tests.typing import MqttMockHAClient
async def test_sensors_hub(
hass: HomeAssistant, config_entry_hub, mqtt_mock: MqttMockHAClient
) -> None:
async def test_sensors_hub(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test DROP sensors for hubs."""
config_entry_hub.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_hub()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
current_flow_sensor_name = "sensor.hub_drop_1_c0ffee_water_flow_rate"
hass.states.async_set(current_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(current_flow_sensor_name).state == STATE_UNKNOWN
peak_flow_sensor_name = "sensor.hub_drop_1_c0ffee_peak_water_flow_rate_today"
hass.states.async_set(peak_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(peak_flow_sensor_name).state == STATE_UNKNOWN
used_today_sensor_name = "sensor.hub_drop_1_c0ffee_total_water_used_today"
hass.states.async_set(used_today_sensor_name, STATE_UNKNOWN)
assert hass.states.get(used_today_sensor_name).state == STATE_UNKNOWN
average_usage_sensor_name = "sensor.hub_drop_1_c0ffee_average_daily_water_usage"
hass.states.async_set(average_usage_sensor_name, STATE_UNKNOWN)
assert hass.states.get(average_usage_sensor_name).state == STATE_UNKNOWN
psi_sensor_name = "sensor.hub_drop_1_c0ffee_current_water_pressure"
hass.states.async_set(psi_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_sensor_name).state == STATE_UNKNOWN
psi_high_sensor_name = "sensor.hub_drop_1_c0ffee_high_water_pressure_today"
hass.states.async_set(psi_high_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_high_sensor_name).state == STATE_UNKNOWN
psi_low_sensor_name = "sensor.hub_drop_1_c0ffee_low_water_pressure_today"
hass.states.async_set(psi_low_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_low_sensor_name).state == STATE_UNKNOWN
battery_sensor_name = "sensor.hub_drop_1_c0ffee_battery"
hass.states.async_set(battery_sensor_name, STATE_UNKNOWN)
assert hass.states.get(battery_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(hass, TEST_DATA_HUB_TOPIC, TEST_DATA_HUB_RESET)
await hass.async_block_till_done()
@ -64,49 +68,47 @@ async def test_sensors_hub(
current_flow_sensor = hass.states.get(current_flow_sensor_name)
assert current_flow_sensor
assert round(float(current_flow_sensor.state), 1) == 5.8
assert current_flow_sensor.state == "5.77"
peak_flow_sensor = hass.states.get(peak_flow_sensor_name)
assert peak_flow_sensor
assert round(float(peak_flow_sensor.state), 1) == 13.8
assert peak_flow_sensor.state == "13.8"
used_today_sensor = hass.states.get(used_today_sensor_name)
assert used_today_sensor
assert round(float(used_today_sensor.state), 1) == 881.1 # liters
assert used_today_sensor.state == "881.13030096168" # liters
average_usage_sensor = hass.states.get(average_usage_sensor_name)
assert average_usage_sensor
assert round(float(average_usage_sensor.state), 1) == 287.7 # liters
assert average_usage_sensor.state == "287.691295584" # liters
psi_sensor = hass.states.get(psi_sensor_name)
assert psi_sensor
assert round(float(psi_sensor.state), 1) == 428.9 # centibars
assert psi_sensor.state == "428.8538854" # centibars
psi_high_sensor = hass.states.get(psi_high_sensor_name)
assert psi_high_sensor
assert round(float(psi_high_sensor.state), 1) == 427.5 # centibars
assert psi_high_sensor.state == "427.474934" # centibars
psi_low_sensor = hass.states.get(psi_low_sensor_name)
assert psi_low_sensor
assert round(float(psi_low_sensor.state), 1) == 420.6 # centibars
assert psi_low_sensor.state == "420.580177" # centibars
battery_sensor = hass.states.get(battery_sensor_name)
assert battery_sensor
assert int(battery_sensor.state) == 50
assert battery_sensor.state == "50"
async def test_sensors_leak(
hass: HomeAssistant, config_entry_leak, mqtt_mock: MqttMockHAClient
) -> None:
async def test_sensors_leak(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test DROP sensors for leak detectors."""
config_entry_leak.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_leak()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
battery_sensor_name = "sensor.leak_detector_battery"
hass.states.async_set(battery_sensor_name, STATE_UNKNOWN)
assert hass.states.get(battery_sensor_name).state == STATE_UNKNOWN
temp_sensor_name = "sensor.leak_detector_temperature"
hass.states.async_set(temp_sensor_name, STATE_UNKNOWN)
assert hass.states.get(temp_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(hass, TEST_DATA_LEAK_TOPIC, TEST_DATA_LEAK_RESET)
await hass.async_block_till_done()
@ -115,29 +117,29 @@ async def test_sensors_leak(
battery_sensor = hass.states.get(battery_sensor_name)
assert battery_sensor
assert int(battery_sensor.state) == 100
assert battery_sensor.state == "100"
temp_sensor = hass.states.get(temp_sensor_name)
assert temp_sensor
assert round(float(temp_sensor.state), 1) == 20.1 # C
assert temp_sensor.state == "20.1111111111111" # °C
async def test_sensors_softener(
hass: HomeAssistant, config_entry_softener, mqtt_mock: MqttMockHAClient
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP sensors for softeners."""
config_entry_softener.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_softener()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
battery_sensor_name = "sensor.softener_battery"
hass.states.async_set(battery_sensor_name, STATE_UNKNOWN)
assert hass.states.get(battery_sensor_name).state == STATE_UNKNOWN
current_flow_sensor_name = "sensor.softener_water_flow_rate"
hass.states.async_set(current_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(current_flow_sensor_name).state == STATE_UNKNOWN
psi_sensor_name = "sensor.softener_current_water_pressure"
hass.states.async_set(psi_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_sensor_name).state == STATE_UNKNOWN
capacity_sensor_name = "sensor.softener_capacity_remaining"
hass.states.async_set(capacity_sensor_name, STATE_UNKNOWN)
assert hass.states.get(capacity_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(hass, TEST_DATA_SOFTENER_TOPIC, TEST_DATA_SOFTENER_RESET)
await hass.async_block_till_done()
@ -146,35 +148,33 @@ async def test_sensors_softener(
battery_sensor = hass.states.get(battery_sensor_name)
assert battery_sensor
assert int(battery_sensor.state) == 20
assert battery_sensor.state == "20"
current_flow_sensor = hass.states.get(current_flow_sensor_name)
assert current_flow_sensor
assert round(float(current_flow_sensor.state), 1) == 5.0
assert current_flow_sensor.state == "5.0"
psi_sensor = hass.states.get(psi_sensor_name)
assert psi_sensor
assert round(float(psi_sensor.state), 1) == 348.2 # centibars
assert psi_sensor.state == "348.1852285" # centibars
capacity_sensor = hass.states.get(capacity_sensor_name)
assert capacity_sensor
assert round(float(capacity_sensor.state), 1) == 3785.4 # liters
assert capacity_sensor.state == "3785.411784" # liters
async def test_sensors_filter(
hass: HomeAssistant, config_entry_filter, mqtt_mock: MqttMockHAClient
) -> None:
async def test_sensors_filter(hass: HomeAssistant, mqtt_mock: MqttMockHAClient) -> None:
"""Test DROP sensors for filters."""
config_entry_filter.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_filter()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
battery_sensor_name = "sensor.filter_battery"
hass.states.async_set(battery_sensor_name, STATE_UNKNOWN)
assert hass.states.get(battery_sensor_name).state == STATE_UNKNOWN
current_flow_sensor_name = "sensor.filter_water_flow_rate"
hass.states.async_set(current_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(current_flow_sensor_name).state == STATE_UNKNOWN
psi_sensor_name = "sensor.filter_current_water_pressure"
hass.states.async_set(psi_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(hass, TEST_DATA_FILTER_TOPIC, TEST_DATA_FILTER_RESET)
await hass.async_block_till_done()
@ -183,33 +183,33 @@ async def test_sensors_filter(
battery_sensor = hass.states.get(battery_sensor_name)
assert battery_sensor
assert round(float(battery_sensor.state), 1) == 12.0
assert battery_sensor.state == "12"
current_flow_sensor = hass.states.get(current_flow_sensor_name)
assert current_flow_sensor
assert round(float(current_flow_sensor.state), 1) == 19.8
assert current_flow_sensor.state == "19.84"
psi_sensor = hass.states.get(psi_sensor_name)
assert psi_sensor
assert round(float(psi_sensor.state), 1) == 263.4 # centibars
assert psi_sensor.state == "263.3797174" # centibars
async def test_sensors_protection_valve(
hass: HomeAssistant, config_entry_protection_valve, mqtt_mock: MqttMockHAClient
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP sensors for protection valves."""
config_entry_protection_valve.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_protection_valve()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
battery_sensor_name = "sensor.protection_valve_battery"
hass.states.async_set(battery_sensor_name, STATE_UNKNOWN)
assert hass.states.get(battery_sensor_name).state == STATE_UNKNOWN
current_flow_sensor_name = "sensor.protection_valve_water_flow_rate"
hass.states.async_set(current_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(current_flow_sensor_name).state == STATE_UNKNOWN
psi_sensor_name = "sensor.protection_valve_current_water_pressure"
hass.states.async_set(psi_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_sensor_name).state == STATE_UNKNOWN
temp_sensor_name = "sensor.protection_valve_temperature"
hass.states.async_set(temp_sensor_name, STATE_UNKNOWN)
assert hass.states.get(temp_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(
hass, TEST_DATA_PROTECTION_VALVE_TOPIC, TEST_DATA_PROTECTION_VALVE_RESET
@ -222,35 +222,35 @@ async def test_sensors_protection_valve(
battery_sensor = hass.states.get(battery_sensor_name)
assert battery_sensor
assert int(battery_sensor.state) == 0
assert battery_sensor.state == "0"
current_flow_sensor = hass.states.get(current_flow_sensor_name)
assert current_flow_sensor
assert round(float(current_flow_sensor.state), 1) == 7.1
assert current_flow_sensor.state == "7.1"
psi_sensor = hass.states.get(psi_sensor_name)
assert psi_sensor
assert round(float(psi_sensor.state), 1) == 422.6 # centibars
assert psi_sensor.state == "422.6486041" # centibars
temp_sensor = hass.states.get(temp_sensor_name)
assert temp_sensor
assert round(float(temp_sensor.state), 1) == 21.4 # C
assert temp_sensor.state == "21.3888888888889" # °C
async def test_sensors_pump_controller(
hass: HomeAssistant, config_entry_pump_controller, mqtt_mock: MqttMockHAClient
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP sensors for pump controllers."""
config_entry_pump_controller.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_pump_controller()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
current_flow_sensor_name = "sensor.pump_controller_water_flow_rate"
hass.states.async_set(current_flow_sensor_name, STATE_UNKNOWN)
assert hass.states.get(current_flow_sensor_name).state == STATE_UNKNOWN
psi_sensor_name = "sensor.pump_controller_current_water_pressure"
hass.states.async_set(psi_sensor_name, STATE_UNKNOWN)
assert hass.states.get(psi_sensor_name).state == STATE_UNKNOWN
temp_sensor_name = "sensor.pump_controller_temperature"
hass.states.async_set(temp_sensor_name, STATE_UNKNOWN)
assert hass.states.get(temp_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(
hass, TEST_DATA_PUMP_CONTROLLER_TOPIC, TEST_DATA_PUMP_CONTROLLER_RESET
@ -263,35 +263,35 @@ async def test_sensors_pump_controller(
current_flow_sensor = hass.states.get(current_flow_sensor_name)
assert current_flow_sensor
assert round(float(current_flow_sensor.state), 1) == 2.2
assert current_flow_sensor.state == "2.2"
psi_sensor = hass.states.get(psi_sensor_name)
assert psi_sensor
assert round(float(psi_sensor.state), 1) == 428.9 # centibars
assert psi_sensor.state == "428.8538854" # centibars
temp_sensor = hass.states.get(temp_sensor_name)
assert temp_sensor
assert round(float(temp_sensor.state), 1) == 20.4 # C
assert temp_sensor.state == "20.4444444444444" # °C
async def test_sensors_ro_filter(
hass: HomeAssistant, config_entry_ro_filter, mqtt_mock: MqttMockHAClient
hass: HomeAssistant, mqtt_mock: MqttMockHAClient
) -> None:
"""Test DROP sensors for RO filters."""
config_entry_ro_filter.add_to_hass(hass)
assert await async_setup_component(hass, DOMAIN, {})
await hass.async_block_till_done()
entry = config_entry_ro_filter()
entry.add_to_hass(hass)
assert await hass.config_entries.async_setup(entry.entry_id)
tds_in_sensor_name = "sensor.ro_filter_inlet_tds"
hass.states.async_set(tds_in_sensor_name, STATE_UNKNOWN)
assert hass.states.get(tds_in_sensor_name).state == STATE_UNKNOWN
tds_out_sensor_name = "sensor.ro_filter_outlet_tds"
hass.states.async_set(tds_out_sensor_name, STATE_UNKNOWN)
assert hass.states.get(tds_out_sensor_name).state == STATE_UNKNOWN
cart1_sensor_name = "sensor.ro_filter_cartridge_1_life_remaining"
hass.states.async_set(cart1_sensor_name, STATE_UNKNOWN)
assert hass.states.get(cart1_sensor_name).state == STATE_UNKNOWN
cart2_sensor_name = "sensor.ro_filter_cartridge_2_life_remaining"
hass.states.async_set(cart2_sensor_name, STATE_UNKNOWN)
assert hass.states.get(cart2_sensor_name).state == STATE_UNKNOWN
cart3_sensor_name = "sensor.ro_filter_cartridge_3_life_remaining"
hass.states.async_set(cart3_sensor_name, STATE_UNKNOWN)
assert hass.states.get(cart3_sensor_name).state == STATE_UNKNOWN
async_fire_mqtt_message(hass, TEST_DATA_RO_FILTER_TOPIC, TEST_DATA_RO_FILTER_RESET)
await hass.async_block_till_done()
@ -300,20 +300,20 @@ async def test_sensors_ro_filter(
tds_in_sensor = hass.states.get(tds_in_sensor_name)
assert tds_in_sensor
assert int(tds_in_sensor.state) == 164
assert tds_in_sensor.state == "164"
tds_out_sensor = hass.states.get(tds_out_sensor_name)
assert tds_out_sensor
assert int(tds_out_sensor.state) == 9
assert tds_out_sensor.state == "9"
cart1_sensor = hass.states.get(cart1_sensor_name)
assert cart1_sensor
assert int(cart1_sensor.state) == 59
assert cart1_sensor.state == "59"
cart2_sensor = hass.states.get(cart2_sensor_name)
assert cart2_sensor
assert int(cart2_sensor.state) == 80
assert cart2_sensor.state == "80"
cart3_sensor = hass.states.get(cart3_sensor_name)
assert cart3_sensor
assert int(cart3_sensor.state) == 59
assert cart3_sensor.state == "59"