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

Replace the usage of unit constants by enumerations in Tests [s-u] (#85937)

Browse Source
This commit is contained in:
Michael 2023-01-16 09:00:27 +01:00 committed by GitHub
parent 0b02abf708
commit 9709391b52
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 254 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/components/scrape/test_sensor.py
View File

@ -18,7 +18,7 @@ from homeassistant.const import (
CONF_UNIT_OF_MEASUREMENT, CONF_UNIT_OF_MEASUREMENT,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
TEMP_CELSIUS, UnitOfTemperature,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -172,7 +172,7 @@ async def test_scrape_uom_and_classes(hass: HomeAssistant) -> None:
state = hass.states.get("sensor.current_temp") state = hass.states.get("sensor.current_temp")
assert state.state == "22.1" assert state.state == "22.1"
assert state.attributes[CONF_UNIT_OF_MEASUREMENT] == TEMP_CELSIUS assert state.attributes[CONF_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
assert state.attributes[CONF_DEVICE_CLASS] == SensorDeviceClass.TEMPERATURE assert state.attributes[CONF_DEVICE_CLASS] == SensorDeviceClass.TEMPERATURE
assert state.attributes[CONF_STATE_CLASS] == SensorStateClass.MEASUREMENT assert state.attributes[CONF_STATE_CLASS] == SensorStateClass.MEASUREMENT

200
tests/components/sensor/test_init.py
View File

@ -9,32 +9,16 @@ from homeassistant.components.number import NumberDeviceClass
from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
from homeassistant.const import ( from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
LENGTH_CENTIMETERS,
LENGTH_INCHES,
LENGTH_KILOMETERS,
LENGTH_METERS,
LENGTH_MILES,
LENGTH_YARD,
MASS_GRAMS,
MASS_OUNCES,
PERCENTAGE, PERCENTAGE,
PRESSURE_HPA,
PRESSURE_INHG,
PRESSURE_KPA,
PRESSURE_MMHG,
SPEED_INCHES_PER_HOUR,
SPEED_KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR,
SPEED_MILLIMETERS_PER_DAY,
STATE_UNKNOWN, STATE_UNKNOWN,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
VOLUME_CUBIC_FEET,
VOLUME_CUBIC_METERS,
VOLUME_FLUID_OUNCE,
VOLUME_LITERS,
UnitOfEnergy, UnitOfEnergy,
UnitOfLength,
UnitOfMass,
UnitOfPressure,
UnitOfSpeed,
UnitOfTemperature, UnitOfTemperature,
UnitOfVolume,
UnitOfVolumetricFlux,
) )
from homeassistant.core import HomeAssistant, State from homeassistant.core import HomeAssistant, State
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -49,10 +33,28 @@ from tests.common import mock_restore_cache_with_extra_data
@pytest.mark.parametrize( @pytest.mark.parametrize(
"unit_system,native_unit,state_unit,native_value,state_value", "unit_system,native_unit,state_unit,native_value,state_value",
[ [
(US_CUSTOMARY_SYSTEM, TEMP_FAHRENHEIT, TEMP_FAHRENHEIT, 100, 100), (
(US_CUSTOMARY_SYSTEM, TEMP_CELSIUS, TEMP_FAHRENHEIT, 38, 100), US_CUSTOMARY_SYSTEM,
(METRIC_SYSTEM, TEMP_FAHRENHEIT, TEMP_CELSIUS, 100, 38), UnitOfTemperature.FAHRENHEIT,
(METRIC_SYSTEM, TEMP_CELSIUS, TEMP_CELSIUS, 38, 38), UnitOfTemperature.FAHRENHEIT,
100,
100,
),
(
US_CUSTOMARY_SYSTEM,
UnitOfTemperature.CELSIUS,
UnitOfTemperature.FAHRENHEIT,
38,
100,
),
(
METRIC_SYSTEM,
UnitOfTemperature.FAHRENHEIT,
UnitOfTemperature.CELSIUS,
100,
38,
),
(METRIC_SYSTEM, UnitOfTemperature.CELSIUS, UnitOfTemperature.CELSIUS, 38, 38),
], ],
) )
async def test_temperature_conversion( async def test_temperature_conversion(
@ -94,7 +96,7 @@ async def test_temperature_conversion_wrong_device_class(
platform.ENTITIES["0"] = platform.MockSensor( platform.ENTITIES["0"] = platform.MockSensor(
name="Test", name="Test",
native_value="0.0", native_value="0.0",
native_unit_of_measurement=TEMP_FAHRENHEIT, native_unit_of_measurement=UnitOfTemperature.FAHRENHEIT,
device_class=device_class, device_class=device_class,
) )
@ -105,7 +107,7 @@ async def test_temperature_conversion_wrong_device_class(
# Check temperature is not converted # Check temperature is not converted
state = hass.states.get(entity0.entity_id) state = hass.states.get(entity0.entity_id)
assert state.state == "0.0" assert state.state == "0.0"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_FAHRENHEIT assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.FAHRENHEIT
@pytest.mark.parametrize("state_class", ("measurement", "total_increasing")) @pytest.mark.parametrize("state_class", ("measurement", "total_increasing"))
@ -407,50 +409,50 @@ async def test_restore_sensor_restore_state(
# Smaller to larger unit, InHg is ~33x larger than hPa -> 1 more decimal # Smaller to larger unit, InHg is ~33x larger than hPa -> 1 more decimal
( (
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_INHG, UnitOfPressure.INHG,
PRESSURE_INHG, UnitOfPressure.INHG,
1000.0, 1000.0,
29.53, 29.53,
), ),
( (
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
PRESSURE_KPA, UnitOfPressure.KPA,
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_HPA, UnitOfPressure.HPA,
1.234, 1.234,
12.34, 12.34,
), ),
( (
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_MMHG, UnitOfPressure.MMHG,
PRESSURE_MMHG, UnitOfPressure.MMHG,
1000, 1000,
750, 750,
), ),
# Not a supported pressure unit # Not a supported pressure unit
( (
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
PRESSURE_HPA, UnitOfPressure.HPA,
"peer_pressure", "peer_pressure",
PRESSURE_HPA, UnitOfPressure.HPA,
1000, 1000,
1000, 1000,
), ),
( (
SensorDeviceClass.TEMPERATURE, SensorDeviceClass.TEMPERATURE,
TEMP_CELSIUS, UnitOfTemperature.CELSIUS,
TEMP_FAHRENHEIT, UnitOfTemperature.FAHRENHEIT,
TEMP_FAHRENHEIT, UnitOfTemperature.FAHRENHEIT,
37.5, 37.5,
99.5, 99.5,
), ),
( (
SensorDeviceClass.TEMPERATURE, SensorDeviceClass.TEMPERATURE,
TEMP_FAHRENHEIT, UnitOfTemperature.FAHRENHEIT,
TEMP_CELSIUS, UnitOfTemperature.CELSIUS,
TEMP_CELSIUS, UnitOfTemperature.CELSIUS,
100, 100,
38.0, 38.0,
), ),
@ -499,25 +501,25 @@ async def test_custom_unit(
[ [
# Distance # Distance
( (
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
LENGTH_MILES, UnitOfLength.MILES,
LENGTH_MILES, UnitOfLength.MILES,
1000, 1000,
621, 621,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,
), ),
( (
LENGTH_CENTIMETERS, UnitOfLength.CENTIMETERS,
LENGTH_INCHES, UnitOfLength.INCHES,
LENGTH_INCHES, UnitOfLength.INCHES,
7.24, 7.24,
2.85, 2.85,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,
), ),
( (
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
"peer_distance", "peer_distance",
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
1000, 1000,
1000, 1000,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,
@ -575,109 +577,109 @@ async def test_custom_unit(
# Pressure # Pressure
# Smaller to larger unit, InHg is ~33x larger than hPa -> 1 more decimal # Smaller to larger unit, InHg is ~33x larger than hPa -> 1 more decimal
( (
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_INHG, UnitOfPressure.INHG,
PRESSURE_INHG, UnitOfPressure.INHG,
1000.0, 1000.0,
29.53, 29.53,
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
), ),
( (
PRESSURE_KPA, UnitOfPressure.KPA,
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_HPA, UnitOfPressure.HPA,
1.234, 1.234,
12.34, 12.34,
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
), ),
( (
PRESSURE_HPA, UnitOfPressure.HPA,
PRESSURE_MMHG, UnitOfPressure.MMHG,
PRESSURE_MMHG, UnitOfPressure.MMHG,
1000, 1000,
750, 750,
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
), ),
# Not a supported pressure unit # Not a supported pressure unit
( (
PRESSURE_HPA, UnitOfPressure.HPA,
"peer_pressure", "peer_pressure",
PRESSURE_HPA, UnitOfPressure.HPA,
1000, 1000,
1000, 1000,
SensorDeviceClass.PRESSURE, SensorDeviceClass.PRESSURE,
), ),
# Speed # Speed
( (
SPEED_KILOMETERS_PER_HOUR, UnitOfSpeed.KILOMETERS_PER_HOUR,
SPEED_MILES_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR,
SPEED_MILES_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR,
100, 100,
62, 62,
SensorDeviceClass.SPEED, SensorDeviceClass.SPEED,
), ),
( (
SPEED_MILLIMETERS_PER_DAY, UnitOfVolumetricFlux.MILLIMETERS_PER_DAY,
SPEED_INCHES_PER_HOUR, UnitOfVolumetricFlux.INCHES_PER_HOUR,
SPEED_INCHES_PER_HOUR, UnitOfVolumetricFlux.INCHES_PER_HOUR,
78, 78,
0.13, 0.13,
SensorDeviceClass.SPEED, SensorDeviceClass.SPEED,
), ),
( (
SPEED_KILOMETERS_PER_HOUR, UnitOfSpeed.KILOMETERS_PER_HOUR,
"peer_distance", "peer_distance",
SPEED_KILOMETERS_PER_HOUR, UnitOfSpeed.KILOMETERS_PER_HOUR,
100, 100,
100, 100,
SensorDeviceClass.SPEED, SensorDeviceClass.SPEED,
), ),
# Volume # Volume
( (
VOLUME_CUBIC_METERS, UnitOfVolume.CUBIC_METERS,
VOLUME_CUBIC_FEET, UnitOfVolume.CUBIC_FEET,
VOLUME_CUBIC_FEET, UnitOfVolume.CUBIC_FEET,
100, 100,
3531, 3531,
SensorDeviceClass.VOLUME, SensorDeviceClass.VOLUME,
), ),
( (
VOLUME_LITERS, UnitOfVolume.LITERS,
VOLUME_FLUID_OUNCE, UnitOfVolume.FLUID_OUNCES,
VOLUME_FLUID_OUNCE, UnitOfVolume.FLUID_OUNCES,
2.3, 2.3,
77.8, 77.8,
SensorDeviceClass.VOLUME, SensorDeviceClass.VOLUME,
), ),
( (
VOLUME_CUBIC_METERS, UnitOfVolume.CUBIC_METERS,
"peer_distance", "peer_distance",
VOLUME_CUBIC_METERS, UnitOfVolume.CUBIC_METERS,
100, 100,
100, 100,
SensorDeviceClass.VOLUME, SensorDeviceClass.VOLUME,
), ),
# Weight # Weight
( (
MASS_GRAMS, UnitOfMass.GRAMS,
MASS_OUNCES, UnitOfMass.OUNCES,
MASS_OUNCES, UnitOfMass.OUNCES,
100, 100,
3.5, 3.5,
SensorDeviceClass.WEIGHT, SensorDeviceClass.WEIGHT,
), ),
( (
MASS_OUNCES, UnitOfMass.OUNCES,
MASS_GRAMS, UnitOfMass.GRAMS,
MASS_GRAMS, UnitOfMass.GRAMS,
78, 78,
2211, 2211,
SensorDeviceClass.WEIGHT, SensorDeviceClass.WEIGHT,
), ),
( (
MASS_GRAMS, UnitOfMass.GRAMS,
"peer_distance", "peer_distance",
MASS_GRAMS, UnitOfMass.GRAMS,
100, 100,
100, 100,
SensorDeviceClass.WEIGHT, SensorDeviceClass.WEIGHT,
@ -746,10 +748,10 @@ async def test_custom_unit_change(
# Distance # Distance
( (
US_CUSTOMARY_SYSTEM, US_CUSTOMARY_SYSTEM,
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
LENGTH_MILES, UnitOfLength.MILES,
LENGTH_METERS, UnitOfLength.METERS,
LENGTH_YARD, UnitOfLength.YARDS,
1000, 1000,
621, 621,
1000000, 1000000,
@ -875,9 +877,9 @@ async def test_unit_conversion_priority(
# Distance # Distance
( (
US_CUSTOMARY_SYSTEM, US_CUSTOMARY_SYSTEM,
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
LENGTH_YARD, UnitOfLength.YARDS,
LENGTH_METERS, UnitOfLength.METERS,
1000, 1000,
1093613, 1093613,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,
@ -956,16 +958,16 @@ async def test_unit_conversion_priority_suggested_unit_change(
# Distance # Distance
( (
US_CUSTOMARY_SYSTEM, US_CUSTOMARY_SYSTEM,
LENGTH_KILOMETERS, UnitOfLength.KILOMETERS,
LENGTH_MILES, UnitOfLength.MILES,
1000, 1000,
621, 621,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,
), ),
( (
US_CUSTOMARY_SYSTEM, US_CUSTOMARY_SYSTEM,
LENGTH_METERS, UnitOfLength.METERS,
LENGTH_MILES, UnitOfLength.MILES,
1000000, 1000000,
621.371, 621.371,
SensorDeviceClass.DISTANCE, SensorDeviceClass.DISTANCE,

7
tests/components/sensor/test_significant_change.py
View File

@ -5,8 +5,7 @@ from homeassistant.components.sensor import SensorDeviceClass, significant_chang
from homeassistant.const import ( from homeassistant.const import (
ATTR_DEVICE_CLASS, ATTR_DEVICE_CLASS,
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
TEMP_CELSIUS, UnitOfTemperature,
TEMP_FAHRENHEIT,
) )
AQI_ATTRS = { AQI_ATTRS = {
@ -23,12 +22,12 @@ HUMIDITY_ATTRS = {
TEMP_CELSIUS_ATTRS = { TEMP_CELSIUS_ATTRS = {
ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE, ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE,
ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS, ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
} }
TEMP_FREEDOM_ATTRS = { TEMP_FREEDOM_ATTRS = {
ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE, ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE,
ATTR_UNIT_OF_MEASUREMENT: TEMP_FAHRENHEIT, ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.FAHRENHEIT,
} }

4
tests/components/sma/test_sensor.py
View File

@ -1,9 +1,9 @@
"""Test the sma sensor platform.""" """Test the sma sensor platform."""
from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, POWER_WATT from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, UnitOfPower
async def test_sensors(hass, init_integration): async def test_sensors(hass, init_integration):
"""Test states of the sensors.""" """Test states of the sensors."""
state = hass.states.get("sensor.sma_device_grid_power") state = hass.states.get("sensor.sma_device_grid_power")
assert state assert state
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == POWER_WATT assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfPower.WATT

4
tests/components/smhi/test_weather.py
View File

@ -31,7 +31,7 @@ from homeassistant.components.weather import (
ATTR_WEATHER_WIND_SPEED_UNIT, ATTR_WEATHER_WIND_SPEED_UNIT,
DOMAIN as WEATHER_DOMAIN, DOMAIN as WEATHER_DOMAIN,
) )
from homeassistant.const import ATTR_ATTRIBUTION, SPEED_METERS_PER_SECOND, STATE_UNKNOWN from homeassistant.const import ATTR_ATTRIBUTION, STATE_UNKNOWN, UnitOfSpeed
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
from homeassistant.util.dt import utcnow from homeassistant.util.dt import utcnow
@ -343,7 +343,7 @@ async def test_custom_speed_unit(
entity_reg.async_update_entity_options( entity_reg.async_update_entity_options(
state.entity_id, state.entity_id,
WEATHER_DOMAIN, WEATHER_DOMAIN,
{ATTR_WEATHER_WIND_SPEED_UNIT: SPEED_METERS_PER_SECOND}, {ATTR_WEATHER_WIND_SPEED_UNIT: UnitOfSpeed.METERS_PER_SECOND},
) )
await hass.async_block_till_done() await hass.async_block_till_done()

4
tests/components/sonarr/test_sensor.py
View File

@ -9,8 +9,8 @@ from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.const import ( from homeassistant.const import (
ATTR_ICON, ATTR_ICON,
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
DATA_GIGABYTES,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
UnitOfInformation,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -56,7 +56,7 @@ async def test_sensors(
state = hass.states.get("sensor.sonarr_disk_space") state = hass.states.get("sensor.sonarr_disk_space")
assert state assert state
assert state.attributes.get(ATTR_ICON) == "mdi:harddisk" assert state.attributes.get(ATTR_ICON) == "mdi:harddisk"
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.attributes.get("C:\\") == "263.10/465.42GB (56.53%)" assert state.attributes.get("C:\\") == "263.10/465.42GB (56.53%)"
assert state.state == "263.10" assert state.state == "263.10"

24
tests/components/spaceapi/test_init.py
View File

@ -7,7 +7,7 @@ from unittest.mock import patch
import pytest import pytest
from homeassistant.components.spaceapi import DOMAIN, SPACEAPI_VERSION, URL_API_SPACEAPI from homeassistant.components.spaceapi import DOMAIN, SPACEAPI_VERSION, URL_API_SPACEAPI
from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, PERCENTAGE, TEMP_CELSIUS from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, PERCENTAGE, UnitOfTemperature
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
from tests.common import mock_coro from tests.common import mock_coro
@ -62,8 +62,18 @@ CONFIG = {
SENSOR_OUTPUT = { SENSOR_OUTPUT = {
"temperature": [ "temperature": [
{"location": "Home", "name": "temp1", "unit": TEMP_CELSIUS, "value": "25"}, {
{"location": "Home", "name": "temp2", "unit": TEMP_CELSIUS, "value": "23"}, "location": "Home",
"name": "temp1",
"unit": UnitOfTemperature.CELSIUS,
"value": "25",
},
{
"location": "Home",
"name": "temp2",
"unit": UnitOfTemperature.CELSIUS,
"value": "23",
},
], ],
"humidity": [ "humidity": [
{"location": "Home", "name": "hum1", "unit": PERCENTAGE, "value": "88"} {"location": "Home", "name": "hum1", "unit": PERCENTAGE, "value": "88"}
@ -78,10 +88,14 @@ def mock_client(hass, hass_client):
hass.loop.run_until_complete(async_setup_component(hass, "spaceapi", CONFIG)) hass.loop.run_until_complete(async_setup_component(hass, "spaceapi", CONFIG))
hass.states.async_set( hass.states.async_set(
"test.temp1", 25, attributes={ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.temp1",
25,
attributes={ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
hass.states.async_set( hass.states.async_set(
"test.temp2", 23, attributes={ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "test.temp2",
23,
attributes={ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
hass.states.async_set( hass.states.async_set(
"test.hum1", 88, attributes={ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE} "test.hum1", 88, attributes={ATTR_UNIT_OF_MEASUREMENT: PERCENTAGE}

4
tests/components/srp_energy/test_sensor.py
View File

@ -11,7 +11,7 @@ from homeassistant.components.srp_energy.const import (
SRP_ENERGY_DOMAIN, SRP_ENERGY_DOMAIN,
) )
from homeassistant.components.srp_energy.sensor import SrpEntity, async_setup_entry from homeassistant.components.srp_energy.sensor import SrpEntity, async_setup_entry
from homeassistant.const import ENERGY_KILO_WATT_HOUR from homeassistant.const import UnitOfEnergy
async def test_async_setup_entry(hass): async def test_async_setup_entry(hass):
@ -89,7 +89,7 @@ async def test_srp_entity(hass):
assert srp_entity.name == f"{DEFAULT_NAME} {SENSOR_NAME}" assert srp_entity.name == f"{DEFAULT_NAME} {SENSOR_NAME}"
assert srp_entity.unique_id == SENSOR_TYPE assert srp_entity.unique_id == SENSOR_TYPE
assert srp_entity.state is None assert srp_entity.state is None
assert srp_entity.unit_of_measurement == ENERGY_KILO_WATT_HOUR assert srp_entity.unit_of_measurement == UnitOfEnergy.KILO_WATT_HOUR
assert srp_entity.icon == ICON assert srp_entity.icon == ICON
assert srp_entity.usage == "2.00" assert srp_entity.usage == "2.00"
assert srp_entity.should_poll is False assert srp_entity.should_poll is False

46
tests/components/startca/test_sensor.py
View File

@ -3,7 +3,7 @@ from http import HTTPStatus
from homeassistant.bootstrap import async_setup_component from homeassistant.bootstrap import async_setup_component
from homeassistant.components.startca.sensor import StartcaData from homeassistant.components.startca.sensor import StartcaData
from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, DATA_GIGABYTES, PERCENTAGE from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, PERCENTAGE, UnitOfInformation
from homeassistant.helpers.aiohttp_client import async_get_clientsession from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -59,47 +59,47 @@ async def test_capped_setup(hass, aioclient_mock):
assert state.state == "76.24" assert state.state == "76.24"
state = hass.states.get("sensor.start_ca_usage") state = hass.states.get("sensor.start_ca_usage")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_data_limit") state = hass.states.get("sensor.start_ca_data_limit")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "400" assert state.state == "400"
state = hass.states.get("sensor.start_ca_used_download") state = hass.states.get("sensor.start_ca_used_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_used_upload") state = hass.states.get("sensor.start_ca_used_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "6.48" assert state.state == "6.48"
state = hass.states.get("sensor.start_ca_used_total") state = hass.states.get("sensor.start_ca_used_total")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "311.43" assert state.state == "311.43"
state = hass.states.get("sensor.start_ca_grace_download") state = hass.states.get("sensor.start_ca_grace_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_grace_upload") state = hass.states.get("sensor.start_ca_grace_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "6.48" assert state.state == "6.48"
state = hass.states.get("sensor.start_ca_grace_total") state = hass.states.get("sensor.start_ca_grace_total")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "311.43" assert state.state == "311.43"
state = hass.states.get("sensor.start_ca_total_download") state = hass.states.get("sensor.start_ca_total_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_total_upload") state = hass.states.get("sensor.start_ca_total_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "6.48" assert state.state == "6.48"
state = hass.states.get("sensor.start_ca_remaining") state = hass.states.get("sensor.start_ca_remaining")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "95.05" assert state.state == "95.05"
@ -155,47 +155,47 @@ async def test_unlimited_setup(hass, aioclient_mock):
assert state.state == "0" assert state.state == "0"
state = hass.states.get("sensor.start_ca_usage") state = hass.states.get("sensor.start_ca_usage")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "0.0" assert state.state == "0.0"
state = hass.states.get("sensor.start_ca_data_limit") state = hass.states.get("sensor.start_ca_data_limit")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "inf" assert state.state == "inf"
state = hass.states.get("sensor.start_ca_used_download") state = hass.states.get("sensor.start_ca_used_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "0.0" assert state.state == "0.0"
state = hass.states.get("sensor.start_ca_used_upload") state = hass.states.get("sensor.start_ca_used_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "0.0" assert state.state == "0.0"
state = hass.states.get("sensor.start_ca_used_total") state = hass.states.get("sensor.start_ca_used_total")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "0.0" assert state.state == "0.0"
state = hass.states.get("sensor.start_ca_grace_download") state = hass.states.get("sensor.start_ca_grace_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_grace_upload") state = hass.states.get("sensor.start_ca_grace_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "6.48" assert state.state == "6.48"
state = hass.states.get("sensor.start_ca_grace_total") state = hass.states.get("sensor.start_ca_grace_total")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "311.43" assert state.state == "311.43"
state = hass.states.get("sensor.start_ca_total_download") state = hass.states.get("sensor.start_ca_total_download")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "304.95" assert state.state == "304.95"
state = hass.states.get("sensor.start_ca_total_upload") state = hass.states.get("sensor.start_ca_total_upload")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "6.48" assert state.state == "6.48"
state = hass.states.get("sensor.start_ca_remaining") state = hass.states.get("sensor.start_ca_remaining")
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == DATA_GIGABYTES assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfInformation.GIGABYTES
assert state.state == "inf" assert state.state == "inf"

56
tests/components/statistics/test_sensor.py
View File

@ -21,7 +21,7 @@ from homeassistant.const import (
SERVICE_RELOAD, SERVICE_RELOAD,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
TEMP_CELSIUS, UnitOfTemperature,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -85,14 +85,14 @@ async def test_sensor_defaults_numeric(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("sensor.test") state = hass.states.get("sensor.test")
assert state is not None assert state is not None
assert state.state == str(round(sum(VALUES_NUMERIC) / len(VALUES_NUMERIC), 2)) assert state.state == str(round(sum(VALUES_NUMERIC) / len(VALUES_NUMERIC), 2))
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get("buffer_usage_ratio") == round(9 / 20, 2) assert state.attributes.get("buffer_usage_ratio") == round(9 / 20, 2)
assert state.attributes.get("source_value_valid") is True assert state.attributes.get("source_value_valid") is True
@ -113,14 +113,16 @@ async def test_sensor_defaults_numeric(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
"0", "0",
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
new_state = hass.states.get("sensor.test") new_state = hass.states.get("sensor.test")
new_mean = round(sum(VALUES_NUMERIC) / (len(VALUES_NUMERIC) + 1), 2) new_mean = round(sum(VALUES_NUMERIC) / (len(VALUES_NUMERIC) + 1), 2)
assert new_state is not None assert new_state is not None
assert new_state.state == str(new_mean) assert new_state.state == str(new_mean)
assert new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert (
new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
)
assert new_state.attributes.get("buffer_usage_ratio") == round(10 / 20, 2) assert new_state.attributes.get("buffer_usage_ratio") == round(10 / 20, 2)
assert new_state.attributes.get("source_value_valid") is True assert new_state.attributes.get("source_value_valid") is True
@ -131,7 +133,9 @@ async def test_sensor_defaults_numeric(hass: HomeAssistant):
new_state = hass.states.get("sensor.test") new_state = hass.states.get("sensor.test")
assert new_state is not None assert new_state is not None
assert new_state.state == str(new_mean) assert new_state.state == str(new_mean)
assert new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert (
new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
)
assert new_state.attributes.get("source_value_valid") is False assert new_state.attributes.get("source_value_valid") is False
# Source sensor has the STATE_UNKNOWN state, unit and state should not change # Source sensor has the STATE_UNKNOWN state, unit and state should not change
@ -141,7 +145,9 @@ async def test_sensor_defaults_numeric(hass: HomeAssistant):
new_state = hass.states.get("sensor.test") new_state = hass.states.get("sensor.test")
assert new_state is not None assert new_state is not None
assert new_state.state == str(new_mean) assert new_state.state == str(new_mean)
assert new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert (
new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
)
assert new_state.attributes.get("source_value_valid") is False assert new_state.attributes.get("source_value_valid") is False
# Source sensor is removed, unit and state should not change # Source sensor is removed, unit and state should not change
@ -151,7 +157,9 @@ async def test_sensor_defaults_numeric(hass: HomeAssistant):
new_state = hass.states.get("sensor.test") new_state = hass.states.get("sensor.test")
assert new_state is not None assert new_state is not None
assert new_state.state == str(new_mean) assert new_state.state == str(new_mean)
assert new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert (
new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
)
assert new_state.attributes.get("source_value_valid") is False assert new_state.attributes.get("source_value_valid") is False
@ -178,7 +186,7 @@ async def test_sensor_defaults_binary(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"binary_sensor.test_monitored", "binary_sensor.test_monitored",
value, value,
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -223,12 +231,12 @@ async def test_sensor_source_with_force_update(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored_normal", "sensor.test_monitored_normal",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored_force", "sensor.test_monitored_force",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -265,7 +273,7 @@ async def test_sampling_size_reduced(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -299,7 +307,7 @@ async def test_sampling_size_1(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -347,7 +355,7 @@ async def test_age_limit_expiry(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -431,7 +439,7 @@ async def test_precision(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -483,7 +491,7 @@ async def test_percentile(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -539,7 +547,7 @@ async def test_device_class(hass: HomeAssistant):
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ {
ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS, ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS,
ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE, ATTR_DEVICE_CLASS: SensorDeviceClass.TEMPERATURE,
}, },
) )
@ -586,7 +594,7 @@ async def test_state_class(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1024,12 +1032,12 @@ async def test_state_characteristics(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(VALUES_NUMERIC[i]), str(VALUES_NUMERIC[i]),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
hass.states.async_set( hass.states.async_set(
"binary_sensor.test_monitored", "binary_sensor.test_monitored",
str(VALUES_BINARY[i]), str(VALUES_BINARY[i]),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1126,7 +1134,7 @@ async def test_invalid_state_characteristic(hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(VALUES_NUMERIC[0]), str(VALUES_NUMERIC[0]),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -1146,7 +1154,7 @@ async def test_initialize_from_database(recorder_mock, hass: HomeAssistant):
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
await async_wait_recording_done(hass) await async_wait_recording_done(hass)
@ -1172,7 +1180,7 @@ async def test_initialize_from_database(recorder_mock, hass: HomeAssistant):
state = hass.states.get("sensor.test") state = hass.states.get("sensor.test")
assert state is not None assert state is not None
assert state.state == str(round(sum(VALUES_NUMERIC) / len(VALUES_NUMERIC), 2)) assert state.state == str(round(sum(VALUES_NUMERIC) / len(VALUES_NUMERIC), 2))
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == TEMP_CELSIUS assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
async def test_initialize_from_database_with_maxage(recorder_mock, hass: HomeAssistant): async def test_initialize_from_database_with_maxage(recorder_mock, hass: HomeAssistant):
@ -1201,7 +1209,7 @@ async def test_initialize_from_database_with_maxage(recorder_mock, hass: HomeAss
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", "sensor.test_monitored",
str(value), str(value),
{ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
mock_data["return_time"] += timedelta(hours=1) mock_data["return_time"] += timedelta(hours=1)

10
tests/components/steamist/test_sensor.py
View File

@ -1,7 +1,7 @@
"""Tests for the steamist sensos.""" """Tests for the steamist sensos."""
from __future__ import annotations from __future__ import annotations
from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, TEMP_CELSIUS, TIME_MINUTES from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, UnitOfTemperature, UnitOfTime
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from . import ( from . import (
@ -16,10 +16,10 @@ async def test_steam_active(hass: HomeAssistant) -> None:
await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_ACTIVE) await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_ACTIVE)
state = hass.states.get("sensor.steam_temperature") state = hass.states.get("sensor.steam_temperature")
assert state.state == "39" assert state.state == "39"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_CELSIUS assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
state = hass.states.get("sensor.steam_minutes_remain") state = hass.states.get("sensor.steam_minutes_remain")
assert state.state == "14" assert state.state == "14"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TIME_MINUTES assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTime.MINUTES
async def test_steam_inactive(hass: HomeAssistant) -> None: async def test_steam_inactive(hass: HomeAssistant) -> None:
@ -27,7 +27,7 @@ async def test_steam_inactive(hass: HomeAssistant) -> None:
await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_INACTIVE) await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_INACTIVE)
state = hass.states.get("sensor.steam_temperature") state = hass.states.get("sensor.steam_temperature")
assert state.state == "21" assert state.state == "21"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TEMP_CELSIUS assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
state = hass.states.get("sensor.steam_minutes_remain") state = hass.states.get("sensor.steam_minutes_remain")
assert state.state == "0" assert state.state == "0"
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == TIME_MINUTES assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTime.MINUTES

18
tests/components/threshold/test_binary_sensor.py
View File

@ -4,7 +4,7 @@ from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
TEMP_CELSIUS, UnitOfTemperature,
) )
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
@ -23,7 +23,9 @@ async def test_sensor_upper(hass):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", 16, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "sensor.test_monitored",
16,
{ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -156,7 +158,9 @@ async def test_sensor_in_range_no_hysteresis(hass):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", 16, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "sensor.test_monitored",
16,
{ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -205,7 +209,9 @@ async def test_sensor_in_range_with_hysteresis(hass):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", 16, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "sensor.test_monitored",
16,
{ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -303,7 +309,9 @@ async def test_sensor_in_range_unknown_state(hass, caplog):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
"sensor.test_monitored", 16, {ATTR_UNIT_OF_MEASUREMENT: TEMP_CELSIUS} "sensor.test_monitored",
16,
{ATTR_UNIT_OF_MEASUREMENT: UnitOfTemperature.CELSIUS},
) )
await hass.async_block_till_done() await hass.async_block_till_done()

8
tests/components/usgs_earthquakes_feed/test_geo_location.py
View File

@ -30,7 +30,7 @@ from homeassistant.const import (
CONF_LONGITUDE, CONF_LONGITUDE,
CONF_RADIUS, CONF_RADIUS,
EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_START,
LENGTH_KILOMETERS, UnitOfLength,
) )
from homeassistant.setup import async_setup_component from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util import homeassistant.util.dt as dt_util
@ -152,7 +152,7 @@ async def test_setup(hass):
ATTR_TYPE: "Type 1", ATTR_TYPE: "Type 1",
ATTR_ALERT: "Alert 1", ATTR_ALERT: "Alert 1",
ATTR_MAGNITUDE: 5.7, ATTR_MAGNITUDE: 5.7,
ATTR_UNIT_OF_MEASUREMENT: LENGTH_KILOMETERS, ATTR_UNIT_OF_MEASUREMENT: UnitOfLength.KILOMETERS,
ATTR_SOURCE: "usgs_earthquakes_feed", ATTR_SOURCE: "usgs_earthquakes_feed",
ATTR_ICON: "mdi:pulse", ATTR_ICON: "mdi:pulse",
} }
@ -166,7 +166,7 @@ async def test_setup(hass):
ATTR_LATITUDE: -31.1, ATTR_LATITUDE: -31.1,
ATTR_LONGITUDE: 150.1, ATTR_LONGITUDE: 150.1,
ATTR_FRIENDLY_NAME: "Title 2", ATTR_FRIENDLY_NAME: "Title 2",
ATTR_UNIT_OF_MEASUREMENT: LENGTH_KILOMETERS, ATTR_UNIT_OF_MEASUREMENT: UnitOfLength.KILOMETERS,
ATTR_SOURCE: "usgs_earthquakes_feed", ATTR_SOURCE: "usgs_earthquakes_feed",
ATTR_ICON: "mdi:pulse", ATTR_ICON: "mdi:pulse",
} }
@ -180,7 +180,7 @@ async def test_setup(hass):
ATTR_LATITUDE: -31.2, ATTR_LATITUDE: -31.2,
ATTR_LONGITUDE: 150.2, ATTR_LONGITUDE: 150.2,
ATTR_FRIENDLY_NAME: "Title 3", ATTR_FRIENDLY_NAME: "Title 3",
ATTR_UNIT_OF_MEASUREMENT: LENGTH_KILOMETERS, ATTR_UNIT_OF_MEASUREMENT: UnitOfLength.KILOMETERS,
ATTR_SOURCE: "usgs_earthquakes_feed", ATTR_SOURCE: "usgs_earthquakes_feed",
ATTR_ICON: "mdi:pulse", ATTR_ICON: "mdi:pulse",
} }

18
tests/components/utility_meter/test_init.py
View File

@ -18,9 +18,9 @@ from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
CONF_PLATFORM, CONF_PLATFORM,
ENERGY_KILO_WATT_HOUR,
EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_START,
Platform, Platform,
UnitOfEnergy,
) )
from homeassistant.core import HomeAssistant, State from homeassistant.core import HomeAssistant, State
from homeassistant.helpers import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -90,7 +90,7 @@ async def test_services(hass, meter):
hass.bus.async_fire(EVENT_HOMEASSISTANT_START) hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
entity_id = config[DOMAIN]["energy_bill"]["source"] entity_id = config[DOMAIN]["energy_bill"]["source"]
hass.states.async_set( hass.states.async_set(
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -99,7 +99,7 @@ async def test_services(hass, meter):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
3, 3,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -120,7 +120,7 @@ async def test_services(hass, meter):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
4, 4,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -148,7 +148,7 @@ async def test_services(hass, meter):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
5, 5,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -214,7 +214,7 @@ async def test_services_config_entry(hass):
hass.bus.async_fire(EVENT_HOMEASSISTANT_START) hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
entity_id = "sensor.energy" entity_id = "sensor.energy"
hass.states.async_set( hass.states.async_set(
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -223,7 +223,7 @@ async def test_services_config_entry(hass):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
3, 3,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -244,7 +244,7 @@ async def test_services_config_entry(hass):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
4, 4,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -272,7 +272,7 @@ async def test_services_config_entry(hass):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
5, 5,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()

68
tests/components/utility_meter/test_sensor.py
View File

@ -32,10 +32,10 @@ from homeassistant.const import (
ATTR_DEVICE_CLASS, ATTR_DEVICE_CLASS,
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_UNIT_OF_MEASUREMENT, ATTR_UNIT_OF_MEASUREMENT,
ENERGY_KILO_WATT_HOUR,
EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_START,
STATE_UNAVAILABLE, STATE_UNAVAILABLE,
STATE_UNKNOWN, STATE_UNKNOWN,
UnitOfEnergy,
) )
from homeassistant.core import CoreState, State from homeassistant.core import CoreState, State
from homeassistant.helpers import entity_registry from homeassistant.helpers import entity_registry
@ -105,7 +105,7 @@ async def test_state(hass, yaml_config, config_entry_config):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -113,26 +113,26 @@ async def test_state(hass, yaml_config, config_entry_config):
assert state is not None assert state is not None
assert state.state == "0" assert state.state == "0"
assert state.attributes.get("status") == COLLECTING assert state.attributes.get("status") == COLLECTING
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.energy_bill_midpeak") state = hass.states.get("sensor.energy_bill_midpeak")
assert state is not None assert state is not None
assert state.state == "0" assert state.state == "0"
assert state.attributes.get("status") == PAUSED assert state.attributes.get("status") == PAUSED
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.energy_bill_offpeak") state = hass.states.get("sensor.energy_bill_offpeak")
assert state is not None assert state is not None
assert state.state == "0" assert state.state == "0"
assert state.attributes.get("status") == PAUSED assert state.attributes.get("status") == PAUSED
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
now = dt_util.utcnow() + timedelta(seconds=10) now = dt_util.utcnow() + timedelta(seconds=10)
with patch("homeassistant.util.dt.utcnow", return_value=now): with patch("homeassistant.util.dt.utcnow", return_value=now):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
3, 3,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -166,7 +166,7 @@ async def test_state(hass, yaml_config, config_entry_config):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
6, 6,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -210,7 +210,7 @@ async def test_state(hass, yaml_config, config_entry_config):
# test invalid state # test invalid state
hass.states.async_set( hass.states.async_set(
entity_id, "*", {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, "*", {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("sensor.energy_bill_midpeak") state = hass.states.get("sensor.energy_bill_midpeak")
@ -219,7 +219,9 @@ async def test_state(hass, yaml_config, config_entry_config):
# test unavailable source # test unavailable source
hass.states.async_set( hass.states.async_set(
entity_id, STATE_UNAVAILABLE, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id,
STATE_UNAVAILABLE,
{ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
) )
await hass.async_block_till_done() await hass.async_block_till_done()
state = hass.states.get("sensor.energy_bill_midpeak") state = hass.states.get("sensor.energy_bill_midpeak")
@ -306,7 +308,7 @@ async def test_init(hass, yaml_config, config_entry_config):
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
hass.states.async_set( hass.states.async_set(
entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -314,12 +316,12 @@ async def test_init(hass, yaml_config, config_entry_config):
state = hass.states.get("sensor.energy_bill_onpeak") state = hass.states.get("sensor.energy_bill_onpeak")
assert state is not None assert state is not None
assert state.state == "0" assert state.state == "0"
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.energy_bill_offpeak") state = hass.states.get("sensor.energy_bill_offpeak")
assert state is not None assert state is not None
assert state.state == "0" assert state.state == "0"
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
async def test_unique_id(hass): async def test_unique_id(hass):
@ -467,7 +469,7 @@ async def test_device_class(hass, yaml_config, config_entry_configs):
await hass.async_block_till_done() await hass.async_block_till_done()
hass.states.async_set( hass.states.async_set(
entity_id_energy, 2, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id_energy, 2, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
hass.states.async_set( hass.states.async_set(
entity_id_gas, 2, {ATTR_UNIT_OF_MEASUREMENT: "some_archaic_unit"} entity_id_gas, 2, {ATTR_UNIT_OF_MEASUREMENT: "some_archaic_unit"}
@ -479,7 +481,7 @@ async def test_device_class(hass, yaml_config, config_entry_configs):
assert state.state == "0" assert state.state == "0"
assert state.attributes.get(ATTR_DEVICE_CLASS) is SensorDeviceClass.ENERGY.value assert state.attributes.get(ATTR_DEVICE_CLASS) is SensorDeviceClass.ENERGY.value
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.TOTAL assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.TOTAL
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.gas_meter") state = hass.states.get("sensor.gas_meter")
assert state is not None assert state is not None
@ -534,7 +536,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
attributes={ attributes={
ATTR_STATUS: PAUSED, ATTR_STATUS: PAUSED,
ATTR_LAST_RESET: last_reset, ATTR_LAST_RESET: last_reset,
ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR, ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR,
}, },
), ),
{ {
@ -555,7 +557,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
attributes={ attributes={
ATTR_STATUS: PAUSED, ATTR_STATUS: PAUSED,
ATTR_LAST_RESET: last_reset, ATTR_LAST_RESET: last_reset,
ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR, ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR,
}, },
), ),
{ {
@ -573,7 +575,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
attributes={ attributes={
ATTR_STATUS: COLLECTING, ATTR_STATUS: COLLECTING,
ATTR_LAST_RESET: last_reset, ATTR_LAST_RESET: last_reset,
ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR, ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR,
}, },
), ),
{ {
@ -591,7 +593,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
attributes={ attributes={
ATTR_STATUS: COLLECTING, ATTR_STATUS: COLLECTING,
ATTR_LAST_RESET: last_reset, ATTR_LAST_RESET: last_reset,
ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR, ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR,
}, },
), ),
{}, {},
@ -618,7 +620,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
assert state.state == "3" assert state.state == "3"
assert state.attributes.get("status") == PAUSED assert state.attributes.get("status") == PAUSED
assert state.attributes.get("last_reset") == last_reset assert state.attributes.get("last_reset") == last_reset
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.energy_bill_midpeak") state = hass.states.get("sensor.energy_bill_midpeak")
assert state.state == "5" assert state.state == "5"
@ -627,7 +629,7 @@ async def test_restore_state(hass, yaml_config, config_entry_config):
assert state.state == "6" assert state.state == "6"
assert state.attributes.get("status") == COLLECTING assert state.attributes.get("status") == COLLECTING
assert state.attributes.get("last_reset") == last_reset assert state.attributes.get("last_reset") == last_reset
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == ENERGY_KILO_WATT_HOUR assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfEnergy.KILO_WATT_HOUR
state = hass.states.get("sensor.energy_bill_superpeak") state = hass.states.get("sensor.energy_bill_superpeak")
assert state.state == STATE_UNKNOWN assert state.state == STATE_UNKNOWN
@ -694,7 +696,7 @@ async def test_net_consumption(hass, yaml_config, config_entry_config):
hass.bus.async_fire(EVENT_HOMEASSISTANT_START) hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
hass.states.async_set( hass.states.async_set(
entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -703,7 +705,7 @@ async def test_net_consumption(hass, yaml_config, config_entry_config):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
1, 1,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -762,7 +764,7 @@ async def test_non_net_consumption(hass, yaml_config, config_entry_config, caplo
hass.bus.async_fire(EVENT_HOMEASSISTANT_START) hass.bus.async_fire(EVENT_HOMEASSISTANT_START)
hass.states.async_set( hass.states.async_set(
entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 2, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -771,7 +773,7 @@ async def test_non_net_consumption(hass, yaml_config, config_entry_config, caplo
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
1, 1,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -781,7 +783,7 @@ async def test_non_net_consumption(hass, yaml_config, config_entry_config, caplo
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
None, None,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -848,7 +850,7 @@ async def test_delta_values(hass, yaml_config, config_entry_config, caplog):
async_fire_time_changed(hass, now) async_fire_time_changed(hass, now)
hass.states.async_set( hass.states.async_set(
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -861,7 +863,7 @@ async def test_delta_values(hass, yaml_config, config_entry_config, caplog):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
None, None,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -873,7 +875,7 @@ async def test_delta_values(hass, yaml_config, config_entry_config, caplog):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
3, 3,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -888,7 +890,7 @@ async def test_delta_values(hass, yaml_config, config_entry_config, caplog):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
6, 6,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -925,7 +927,7 @@ async def _test_self_reset(hass, config, start_time, expect_reset=True):
async_fire_time_changed(hass, now) async_fire_time_changed(hass, now)
hass.states.async_set( hass.states.async_set(
entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR} entity_id, 1, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR}
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -935,7 +937,7 @@ async def _test_self_reset(hass, config, start_time, expect_reset=True):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
3, 3,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -947,7 +949,7 @@ async def _test_self_reset(hass, config, start_time, expect_reset=True):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
6, 6,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()
@ -978,7 +980,7 @@ async def _test_self_reset(hass, config, start_time, expect_reset=True):
hass.states.async_set( hass.states.async_set(
entity_id, entity_id,
10, 10,
{ATTR_UNIT_OF_MEASUREMENT: ENERGY_KILO_WATT_HOUR}, {ATTR_UNIT_OF_MEASUREMENT: UnitOfEnergy.KILO_WATT_HOUR},
force_update=True, force_update=True,
) )
await hass.async_block_till_done() await hass.async_block_till_done()