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

Add default device class display precision for Sensor (#145013)

Browse Source 
* Add default device class display precision for Sensor

* Renaming, docstrings, cleanup

* Simplify units list

* Fix tests

* Fix missing precision when suggested is specified

* Update snapshots

* Fix when unit of measurement is not valid

* Fix tests

* Fix deprecated unit usage

* Fix goalzero tests

The sensor native_value method was accessing the data dict and trowing,
since the mock did not have any data for the sensors.

Since now the precision is always specified (it was missing for those
sensors), the throw was hitting async_update_entity_options in _update_suggested_precision.
Previously, async_update_entity_options was not called since it had no
precision.

* Fix metoffice

* Fix smartthings

* Add default sensor data for Tesla Wall Connector tests

* Update snapshots

* Revert spaces

* Update smartthings snapshots

* Add missing sensor mock for tesla wall connector

* Address review comments

* Add doc comment

* Add cap to doc comment

* Update comment

* Update snapshots

* Update comment
This commit is contained in:
Abílio Costa 2025-05-26 18:40:29 +01:00 committed by GitHub
parent b15989f2bf
commit b626204f63
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
123 changed files with 4523 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
homeassistant/components/sensor/__init__.py
View File

@ -38,6 +38,7 @@ from .const import ( # noqa: F401
ATTR_OPTIONS,
ATTR_STATE_CLASS,
CONF_STATE_CLASS,
DEFAULT_PRECISION_LIMIT,
DEVICE_CLASS_STATE_CLASSES,
DEVICE_CLASS_UNITS,
DEVICE_CLASSES,
@ -48,6 +49,7 @@ from .const import ( # noqa: F401
STATE_CLASSES,
STATE_CLASSES_SCHEMA,
UNIT_CONVERTERS,
UNITS_PRECISION,
SensorDeviceClass,
SensorStateClass,
)
@ -137,6 +139,29 @@ def _numeric_state_expected(
return device_class is not None
def _calculate_precision_from_ratio(
device_class: SensorDeviceClass, from_unit: str, to_unit: str, base_precision: int
) -> int | None:
"""Calculate the precision for a unit conversion.
Adjusts the base precision based on the ratio between the source and target units
for the given sensor device class. Returns the new precision or None if conversion
is not possible.
"""
if device_class not in UNIT_CONVERTERS:
return None
converter = UNIT_CONVERTERS[device_class]
if from_unit not in converter.VALID_UNITS or to_unit not in converter.VALID_UNITS:
return None
# Scale the precision when converting to a larger or smaller unit
# For example 1.1 Wh should be rendered as 0.0011 kWh, not 0.0 kWh
ratio_log = log10(converter.get_unit_ratio(from_unit, to_unit))
ratio_log = floor(ratio_log) if ratio_log > 0 else ceil(ratio_log)
return max(0, base_precision + ratio_log)
CACHED_PROPERTIES_WITH_ATTR_ = {
"device_class",
"last_reset",
@ -663,30 +688,10 @@ class SensorEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
converter := UNIT_CONVERTERS.get(device_class)
):
# Unit conversion needed
converted_numerical_value = converter.converter_factory(
native_unit_of_measurement,
unit_of_measurement,
value = converter.converter_factory(
native_unit_of_measurement, unit_of_measurement
)(float(numerical_value))
# If unit conversion is happening, and there's no rounding for display,
# do a best effort rounding here.
if (
suggested_precision is None
and self._sensor_option_display_precision is None
):
# Deduce the precision by finding the decimal point, if any
value_s = str(value)
# Scale the precision when converting to a larger unit
# For example 1.1 Wh should be rendered as 0.0011 kWh, not 0.0 kWh
precision = (
len(value_s) - value_s.index(".") - 1 if "." in value_s else 0
) + converter.get_unit_floored_log_ratio(
native_unit_of_measurement, unit_of_measurement
)
value = f"{converted_numerical_value:z.{precision}f}"
else:
value = converted_numerical_value
# Validate unit of measurement used for sensors with a device class
if (
not self._invalid_unit_of_measurement_reported
@ -739,34 +744,78 @@ class SensorEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
return cast(int, precision)
return None
def _update_suggested_precision(self) -> None:
"""Update suggested display precision stored in registry."""
assert self.registry_entry
def _get_adjusted_display_precision(self) -> int | None:
"""Return the display precision for the sensor.
device_class = self.device_class
When the integration has specified a suggested display precision, it will be used.
If a unit conversion is needed, the display precision will be adjusted based on
the ratio from the native unit to the current one.
When the integration does not specify a suggested display precision, a default
device class precision will be used from UNITS_PRECISION, and the final precision
will be adjusted based on the ratio from the default unit to the current one. It
will also be capped so that the extra precision (from the base unit) does not
exceed DEFAULT_PRECISION_LIMIT.
"""
display_precision = self.suggested_display_precision
device_class = self.device_class
if device_class is None:
return display_precision
default_unit_of_measurement = (
self.suggested_unit_of_measurement or self.native_unit_of_measurement
)
if default_unit_of_measurement is None:
return display_precision
unit_of_measurement = self.unit_of_measurement
if unit_of_measurement is None:
return display_precision
if (
display_precision is not None
and default_unit_of_measurement != unit_of_measurement
and device_class in UNIT_CONVERTERS
):
converter = UNIT_CONVERTERS[device_class]
# Scale the precision when converting to a larger or smaller unit
# For example 1.1 Wh should be rendered as 0.0011 kWh, not 0.0 kWh
ratio_log = log10(
converter.get_unit_ratio(
default_unit_of_measurement, unit_of_measurement
if display_precision is not None:
if default_unit_of_measurement != unit_of_measurement:
return (
_calculate_precision_from_ratio(
device_class,
default_unit_of_measurement,
unit_of_measurement,
display_precision,
)
or display_precision
)
)
ratio_log = floor(ratio_log) if ratio_log > 0 else ceil(ratio_log)
display_precision = max(0, display_precision + ratio_log)
return display_precision
# Get the base unit and precision for the device class so we can use it to infer
# the display precision for the current unit
if device_class not in UNITS_PRECISION:
return None
device_class_base_unit, device_class_base_precision = UNITS_PRECISION[
device_class
]
precision = (
_calculate_precision_from_ratio(
device_class,
device_class_base_unit,
unit_of_measurement,
device_class_base_precision,
)
if device_class_base_unit != unit_of_measurement
else device_class_base_precision
)
if precision is None:
return None
# Since we are inferring the precision from the device class, cap it to avoid
# having too many decimals
return min(precision, device_class_base_precision + DEFAULT_PRECISION_LIMIT)
def _update_suggested_precision(self) -> None:
"""Update suggested display precision stored in registry."""
display_precision = self._get_adjusted_display_precision()
assert self.registry_entry
sensor_options: Mapping[str, Any] = self.registry_entry.options.get(DOMAIN, {})
if "suggested_display_precision" not in sensor_options:
if display_precision is None:

47
homeassistant/components/sensor/const.py
View File

@ -643,6 +643,53 @@ DEVICE_CLASS_UNITS: dict[SensorDeviceClass, set[type[StrEnum] | str | None]] = {
SensorDeviceClass.WIND_SPEED: set(UnitOfSpeed),
}
# Maximum precision (decimals) deviation from default device class precision.
DEFAULT_PRECISION_LIMIT = 2
# Map one unit for each device class to its default precision.
# The biggest unit with the lowest precision should be used. For example, if W should
# have 0 decimals, that one should be used and not mW, even though mW also should have
# 0 decimals. Otherwise the smaller units will have more decimals than expected.
UNITS_PRECISION = {
SensorDeviceClass.APPARENT_POWER: (UnitOfApparentPower.VOLT_AMPERE, 0),
SensorDeviceClass.AREA: (UnitOfArea.SQUARE_CENTIMETERS, 0),
SensorDeviceClass.ATMOSPHERIC_PRESSURE: (UnitOfPressure.PA, 0),
SensorDeviceClass.BLOOD_GLUCOSE_CONCENTRATION: (
UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER,
0,
),
SensorDeviceClass.CONDUCTIVITY: (UnitOfConductivity.MICROSIEMENS_PER_CM, 1),
SensorDeviceClass.CURRENT: (UnitOfElectricCurrent.MILLIAMPERE, 0),
SensorDeviceClass.DATA_RATE: (UnitOfDataRate.KILOBITS_PER_SECOND, 0),
SensorDeviceClass.DATA_SIZE: (UnitOfInformation.KILOBITS, 0),
SensorDeviceClass.DISTANCE: (UnitOfLength.CENTIMETERS, 0),
SensorDeviceClass.DURATION: (UnitOfTime.MILLISECONDS, 0),
SensorDeviceClass.ENERGY: (UnitOfEnergy.WATT_HOUR, 0),
SensorDeviceClass.ENERGY_DISTANCE: (UnitOfEnergyDistance.KM_PER_KILO_WATT_HOUR, 0),
SensorDeviceClass.ENERGY_STORAGE: (UnitOfEnergy.WATT_HOUR, 0),
SensorDeviceClass.FREQUENCY: (UnitOfFrequency.HERTZ, 0),
SensorDeviceClass.GAS: (UnitOfVolume.MILLILITERS, 0),
SensorDeviceClass.IRRADIANCE: (UnitOfIrradiance.WATTS_PER_SQUARE_METER, 0),
SensorDeviceClass.POWER: (UnitOfPower.WATT, 0),
SensorDeviceClass.PRECIPITATION: (UnitOfPrecipitationDepth.CENTIMETERS, 0),
SensorDeviceClass.PRECIPITATION_INTENSITY: (
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
0,
),
SensorDeviceClass.PRESSURE: (UnitOfPressure.PA, 0),
SensorDeviceClass.REACTIVE_POWER: (UnitOfReactivePower.VOLT_AMPERE_REACTIVE, 0),
SensorDeviceClass.SOUND_PRESSURE: (UnitOfSoundPressure.DECIBEL, 0),
SensorDeviceClass.SPEED: (UnitOfSpeed.MILLIMETERS_PER_SECOND, 0),
SensorDeviceClass.TEMPERATURE: (UnitOfTemperature.KELVIN, 1),
SensorDeviceClass.VOLTAGE: (UnitOfElectricPotential.VOLT, 0),
SensorDeviceClass.VOLUME: (UnitOfVolume.MILLILITERS, 0),
SensorDeviceClass.VOLUME_FLOW_RATE: (UnitOfVolumeFlowRate.LITERS_PER_SECOND, 0),
SensorDeviceClass.VOLUME_STORAGE: (UnitOfVolume.MILLILITERS, 0),
SensorDeviceClass.WATER: (UnitOfVolume.MILLILITERS, 0),
SensorDeviceClass.WEIGHT: (UnitOfMass.GRAMS, 0),
SensorDeviceClass.WIND_SPEED: (UnitOfSpeed.MILLIMETERS_PER_SECOND, 0),
}
DEVICE_CLASS_STATE_CLASSES: dict[SensorDeviceClass, set[SensorStateClass]] = {
SensorDeviceClass.APPARENT_POWER: {SensorStateClass.MEASUREMENT},
SensorDeviceClass.AQI: {SensorStateClass.MEASUREMENT},

25
tests/common.py
View File

@ -1959,3 +1959,28 @@ def get_schema_suggested_value(schema: vol.Schema, key: str) -> Any | None:
return None
return schema_key.description["suggested_value"]
return None
def get_sensor_display_state(
hass: HomeAssistant, entity_registry: er.EntityRegistry, entity_id: str
) -> str:
"""Return the state rounded for presentation."""
state = hass.states.get(entity_id)
assert state
value = state.state
entity_entry = entity_registry.async_get(entity_id)
if entity_entry is None:
return value
if (
precision := entity_entry.options.get("sensor", {}).get(
"suggested_display_precision"
)
) is None:
return value
with suppress(TypeError, ValueError):
numerical_value = float(value)
value = f"{numerical_value:z.{precision}f}"
return value

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

@ -1,5 +1,7 @@
"""Tests for the Abode sensor device."""
import pytest
from homeassistant.components.abode import ATTR_DEVICE_ID
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
from homeassistant.const import (
@ -45,5 +47,5 @@ async def test_attributes(hass: HomeAssistant) -> None:
state = hass.states.get("sensor.environment_sensor_temperature")
# Abodepy device JSON reports 19.5, but Home Assistant shows 19.4
assert state.state == "19.4"
assert float(state.state) == pytest.approx(19.44444)
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS

3
tests/components/acaia/snapshots/test_sensor.ambr
View File

@ -132,6 +132,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.WEIGHT: 'weight'>,
'original_icon': None,

180
tests/components/accuweather/snapshots/test_sensor.ambr
View File

@ -348,6 +348,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1502,6 +1505,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2370,6 +2376,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION_INTENSITY: 'precipitation_intensity'>,
'original_icon': None,
@ -2798,6 +2807,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2850,6 +2862,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2901,6 +2916,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2952,6 +2970,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3003,6 +3024,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3054,6 +3078,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3105,6 +3132,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3156,6 +3186,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3207,6 +3240,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3258,6 +3294,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3309,6 +3348,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3362,6 +3404,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3414,6 +3459,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3465,6 +3513,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3516,6 +3567,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3567,6 +3621,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3618,6 +3675,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3669,6 +3729,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3720,6 +3783,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3771,6 +3837,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3822,6 +3891,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3873,6 +3945,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3924,6 +3999,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -3975,6 +4053,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4026,6 +4107,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4077,6 +4161,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4128,6 +4215,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4179,6 +4269,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4230,6 +4323,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4281,6 +4377,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4332,6 +4431,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4383,6 +4485,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.IRRADIANCE: 'irradiance'>,
'original_icon': None,
@ -4436,6 +4541,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5554,6 +5662,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5608,6 +5719,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5662,6 +5776,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5714,6 +5831,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5766,6 +5886,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5818,6 +5941,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5870,6 +5996,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5922,6 +6051,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -5974,6 +6106,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6026,6 +6161,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6078,6 +6216,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6130,6 +6271,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6182,6 +6326,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6236,6 +6383,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6288,6 +6438,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6340,6 +6493,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6392,6 +6548,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6444,6 +6603,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6496,6 +6658,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6548,6 +6713,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6600,6 +6768,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6652,6 +6823,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6704,6 +6878,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6756,6 +6933,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,

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

@ -163,12 +163,12 @@ async def test_sensor_imperial_units(
state = hass.states.get("sensor.home_wind_speed")
assert state
assert state.state == "9.0"
assert float(state.state) == pytest.approx(9.00988)
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfSpeed.MILES_PER_HOUR
state = hass.states.get("sensor.home_realfeel_temperature")
assert state
assert state.state == "77.2"
assert state.state == "77.18"
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.FAHRENHEIT
)

21
tests/components/airgradient/snapshots/test_sensor.ambr
View File

@ -74,6 +74,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -502,6 +505,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -975,6 +981,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1077,6 +1086,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1127,6 +1139,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1228,6 +1243,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1486,6 +1504,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

31
tests/components/airzone/snapshots/test_sensor.ambr
View File

@ -76,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -129,6 +132,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -235,6 +241,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -446,6 +455,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -472,7 +484,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '21.20',
'state': '21.2',
})
# ---
# name: test_airzone_create_sensors[sensor.dkn_plus_temperature-entry]
@ -499,6 +511,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -525,7 +540,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '21.7',
'state': '21.6666666666667',
})
# ---
# name: test_airzone_create_sensors[sensor.dorm_1_battery-entry]
@ -710,6 +725,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -921,6 +939,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1132,6 +1153,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1238,6 +1262,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

39
tests/components/apcupsd/snapshots/test_sensor.ambr
View File

@ -123,6 +123,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -321,6 +324,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -614,6 +620,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -667,6 +676,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1010,6 +1022,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -1060,6 +1075,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1110,6 +1128,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1162,6 +1183,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -1649,6 +1673,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1702,6 +1729,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1755,6 +1785,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1905,6 +1938,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1955,6 +1991,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

27
tests/components/apsystems/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -235,6 +247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -288,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -341,6 +359,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -394,6 +415,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -447,6 +471,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,

6
tests/components/aquacell/snapshots/test_sensor.ambr
View File

@ -123,6 +123,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -225,6 +228,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

3
tests/components/arve/snapshots/test_sensor.ambr
View File

@ -208,6 +208,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

45
tests/components/autarco/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -235,6 +247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -288,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -341,6 +359,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -447,6 +468,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -500,6 +524,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -553,6 +580,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -606,6 +636,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -659,6 +692,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -712,6 +748,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -765,6 +804,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -818,6 +860,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,

6
tests/components/bluemaestro/snapshots/test_sensor.ambr
View File

@ -76,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -235,6 +238,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

6
tests/components/bsblan/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

15
tests/components/deconz/snapshots/test_sensor.ambr
View File

@ -181,6 +181,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -869,6 +872,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -925,6 +931,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -1302,6 +1311,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2206,6 +2218,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,

9
tests/components/devolo_home_control/snapshots/test_sensor.ambr
View File

@ -144,6 +144,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -197,6 +200,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -250,6 +256,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

44
tests/components/ecovacs/snapshots/test_sensor.ambr
View File

@ -175,6 +175,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfArea.SQUARE_METERS: 'm²'>,
}),
@ -203,7 +206,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.0010',
'state': '0.001',
})
# ---
# name: test_sensors[5xu9h3][sensor.goat_g1_battery:entity-registry]
@ -327,6 +330,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
}),
@ -528,6 +534,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.AREA: 'area'>,
'original_icon': None,
@ -581,6 +590,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -610,7 +622,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '40.000',
'state': '40.0',
})
# ---
# name: test_sensors[5xu9h3][sensor.goat_g1_total_cleanings:entity-registry]
@ -782,6 +794,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfArea.SQUARE_METERS: 'm²'>,
}),
@ -885,6 +900,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
}),
@ -1291,6 +1309,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.AREA: 'area'>,
'original_icon': None,
@ -1344,6 +1365,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -1373,7 +1397,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '40.000',
'state': '40.0',
})
# ---
# name: test_sensors[qhe2o2][sensor.dusty_total_cleanings:entity-registry]
@ -1594,6 +1618,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfArea.SQUARE_METERS: 'm²'>,
}),
@ -1697,6 +1724,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.MINUTES: 'min'>,
}),
@ -1996,6 +2026,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.AREA: 'area'>,
'original_icon': None,
@ -2049,6 +2082,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -2078,7 +2114,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '40.000',
'state': '40.0',
})
# ---
# name: test_sensors[yna5x1][sensor.ozmo_950_total_cleanings:entity-registry]

3
tests/components/eheimdigital/snapshots/test_sensor.ambr
View File

@ -130,6 +130,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.DAYS: 'd'>,
}),

8
tests/components/eheimdigital/test_sensor.py
View File

@ -12,7 +12,7 @@ from homeassistant.helpers import entity_registry as er
from .conftest import init_integration
from tests.common import MockConfigEntry, snapshot_platform
from tests.common import MockConfigEntry, get_sensor_display_state, snapshot_platform
@pytest.mark.usefixtures("classic_vario_mock")
@ -69,7 +69,7 @@ async def test_setup_classic_vario(
"classic_vario_data",
"serviceHour",
100,
str(round(100 / 24, 1)),
str(round(100 / 24, 2)),
),
],
),
@ -77,6 +77,7 @@ async def test_setup_classic_vario(
)
async def test_state_update(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
eheimdigital_hub_mock: MagicMock,
mock_config_entry: MockConfigEntry,
device_name: str,
@ -96,5 +97,4 @@ async def test_state_update(
for item in entity_list:
getattr(device, item[1])[item[2]] = item[3]
await eheimdigital_hub_mock.call_args.kwargs["receive_callback"]()
assert (state := hass.states.get(item[0]))
assert state.state == str(item[4])
assert get_sensor_display_state(hass, entity_registry, item[0]) == str(item[4])

3
tests/components/emoncms/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

12
tests/components/enphase_envoy/snapshots/test_diagnostics.ambr
View File

@ -336,6 +336,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': 'power',
'original_icon': None,
@ -791,6 +794,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': 'power',
'original_icon': None,
@ -1288,6 +1294,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': 'power',
'original_icon': None,
@ -1557,6 +1566,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': 'power',
'original_icon': None,

92
tests/components/enphase_envoy/snapshots/test_sensor.ambr
View File

@ -256,6 +256,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1793,6 +1796,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2005,6 +2011,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2055,6 +2064,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -2204,6 +2216,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2254,6 +2269,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2304,6 +2322,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
'original_icon': None,
@ -2354,6 +2375,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
'original_icon': None,
@ -2454,6 +2478,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
'original_icon': None,
@ -2504,6 +2531,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2663,6 +2693,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -6170,6 +6203,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -6744,6 +6780,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -6844,6 +6883,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -6993,6 +7035,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -7043,6 +7088,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -7093,6 +7141,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -7252,6 +7303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -10759,6 +10813,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -11333,6 +11390,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -11433,6 +11493,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -11582,6 +11645,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -11632,6 +11698,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11731,6 +11800,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11756,7 +11828,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '26',
'state': '26.1111111111111',
})
# ---
# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_available_battery_energy-entry]
@ -11781,6 +11853,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -12117,6 +12192,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -18783,6 +18861,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -19829,6 +19910,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -25671,6 +25755,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -26461,6 +26548,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,

6
tests/components/filesize/snapshots/test_sensor.ambr
View File

@ -121,6 +121,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -174,6 +177,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,

15
tests/components/flexit_bacnet/snapshots/test_sensor.ambr
View File

@ -233,6 +233,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -283,6 +286,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -493,6 +499,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -599,6 +608,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -753,6 +765,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

24
tests/components/fritz/snapshots/test_sensor.ambr
View File

@ -72,6 +72,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -221,6 +224,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -274,6 +280,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -472,6 +481,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -620,6 +632,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -670,6 +685,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -720,6 +738,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -772,6 +793,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,

27
tests/components/fritzbox/snapshots/test_sensor.ambr
View File

@ -127,6 +127,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -225,6 +228,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -372,6 +378,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -530,6 +539,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -583,6 +595,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -636,6 +651,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -689,6 +707,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -742,6 +763,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -795,6 +819,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

372
tests/components/fronius/snapshots/test_sensor.ambr
View File

File diff suppressed because it is too large Load Diff

6
tests/components/fujitsu_fglair/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

12
tests/components/fyta/snapshots/test_sensor.ambr
View File

@ -591,6 +591,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 3,
}),
}),
'original_device_class': <SensorDeviceClass.CONDUCTIVITY: 'conductivity'>,
'original_icon': None,
@ -758,6 +761,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1445,6 +1451,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 3,
}),
}),
'original_device_class': <SensorDeviceClass.CONDUCTIVITY: 'conductivity'>,
'original_icon': None,
@ -1612,6 +1621,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

75
tests/components/glances/snapshots/test_sensor.ambr
View File

@ -126,6 +126,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -179,6 +182,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -232,6 +238,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -261,7 +270,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.000000',
'state': '0.0',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_dummy0_tx-entry]
@ -288,6 +297,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -317,7 +329,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.000000',
'state': '0.0',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_err_temp_temperature-entry]
@ -344,6 +356,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -397,6 +412,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -426,7 +444,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.03162',
'state': '0.031624',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_eth0_tx-entry]
@ -453,6 +471,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -509,6 +530,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -538,7 +562,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.06117',
'state': '0.061168',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_lo_tx-entry]
@ -565,6 +589,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABITS_PER_SECOND: 'Mbit/s'>,
}),
@ -594,7 +621,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.06117',
'state': '0.061168',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_md1_available-entry]
@ -825,6 +852,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -930,6 +960,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -983,6 +1016,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -1088,6 +1124,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -1141,6 +1180,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1353,6 +1395,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1406,6 +1451,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABYTES_PER_SECOND: 'MB/s'>,
}),
@ -1435,7 +1483,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.184320',
'state': '0.18432',
})
# ---
# name: test_sensor_states[sensor.0_0_0_0_nvme0n1_disk_write-entry]
@ -1462,6 +1510,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABYTES_PER_SECOND: 'MB/s'>,
}),
@ -1518,6 +1569,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABYTES_PER_SECOND: 'MB/s'>,
}),
@ -1574,6 +1628,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfDataRate.MEGABYTES_PER_SECOND: 'MB/s'>,
}),
@ -1630,6 +1687,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -1735,6 +1795,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,

2
tests/components/hddtemp/test_sensor.py
View File

@ -132,7 +132,7 @@ async def test_hddtemp_one_disk(hass: HomeAssistant, telnetmock) -> None:
reference = REFERENCE[state.attributes.get("device")]
assert state.state == reference["temperature"]
assert round(float(state.state), 0) == float(reference["temperature"])
assert state.attributes.get("device") == reference["device"]
assert state.attributes.get("model") == reference["model"]
assert (

51
tests/components/homee/snapshots/test_sensor.ambr
View File

@ -129,6 +129,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -182,6 +185,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -288,6 +294,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -341,6 +350,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -394,6 +406,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -763,6 +778,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -868,6 +886,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME_STORAGE: 'volume_storage'>,
'original_icon': None,
@ -1054,6 +1075,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1160,6 +1184,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1329,6 +1356,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1382,6 +1412,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -1435,6 +1468,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1488,6 +1524,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1541,6 +1580,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1645,6 +1687,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1698,6 +1743,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1751,6 +1799,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
}),

123
tests/components/homekit_controller/snapshots/test_init.ambr
View File

@ -2714,6 +2714,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2931,6 +2934,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2978,6 +2984,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -3025,6 +3034,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -3072,6 +3084,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -3119,6 +3134,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3166,6 +3184,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3428,6 +3449,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3907,6 +3931,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4079,6 +4106,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4251,6 +4281,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4518,6 +4551,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5817,6 +5853,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -6598,6 +6637,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -7254,6 +7296,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -7517,6 +7562,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -8259,6 +8307,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -8686,6 +8737,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -8858,6 +8912,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -9030,6 +9087,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -9522,6 +9582,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -9788,6 +9851,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -10065,6 +10131,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -10207,6 +10276,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -10340,6 +10412,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -10387,6 +10462,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -10434,6 +10512,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -10481,6 +10562,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -12052,6 +12136,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -13769,6 +13856,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -14895,6 +14985,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -17441,6 +17534,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -17617,6 +17713,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -17998,6 +18097,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -19190,6 +19292,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -20231,6 +20336,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -20278,6 +20386,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -22588,6 +22699,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -23029,6 +23143,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -23338,6 +23455,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -24180,6 +24300,9 @@
]),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,

396
tests/components/homewizard/snapshots/test_sensor.ambr
View File

File diff suppressed because it is too large Load Diff

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

@ -9,7 +9,7 @@ from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
@pytest.mark.parametrize(("unit", "temp"), [("C", "5"), ("F", "-15")])
@pytest.mark.parametrize(("unit", "temp"), [("C", 5), ("F", -15)])
async def test_outdoor_sensor(
hass: HomeAssistant,
config_entry: MockConfigEntry,
@ -32,11 +32,11 @@ async def test_outdoor_sensor(
assert temperature_state
assert humidity_state
assert temperature_state.state == temp
assert humidity_state.state == "25"
assert float(temperature_state.state) == temp
assert float(humidity_state.state) == 25
@pytest.mark.parametrize(("unit", "temp"), [("C", "5"), ("F", "-15")])
@pytest.mark.parametrize(("unit", "temp"), [("C", 5), ("F", -15)])
async def test_indoor_sensor(
hass: HomeAssistant,
config_entry: MockConfigEntry,
@ -62,5 +62,5 @@ async def test_indoor_sensor(
assert temperature_state
assert humidity_state
assert temperature_state.state == temp
assert float(temperature_state.state) == temp
assert humidity_state.state == "25"

28
tests/components/husqvarna_automower/snapshots/test_sensor.ambr
View File

@ -76,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -105,7 +108,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.034',
'state': '0.0341666666666667',
})
# ---
# name: test_sensor_snapshot[sensor.test_mower_1_downtime-entry]
@ -996,6 +999,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -1025,7 +1031,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1204.000',
'state': '1204.0',
})
# ---
# name: test_sensor_snapshot[sensor.test_mower_1_total_cutting_time-entry]
@ -1052,6 +1058,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -1081,7 +1090,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1165.000',
'state': '1165.0',
})
# ---
# name: test_sensor_snapshot[sensor.test_mower_1_total_drive_distance-entry]
@ -1108,6 +1117,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfLength.KILOMETERS: 'km'>,
}),
@ -1164,6 +1176,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -1193,7 +1208,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1268.000',
'state': '1268.0',
})
# ---
# name: test_sensor_snapshot[sensor.test_mower_1_total_searching_time-entry]
@ -1220,6 +1235,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -1249,7 +1267,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '103.000',
'state': '103.0',
})
# ---
# name: test_sensor_snapshot[sensor.test_mower_1_uptime-entry]

2
tests/components/husqvarna_automower/test_sensor.py
View File

@ -53,7 +53,7 @@ async def test_cutting_blade_usage_time_sensor(
await setup_integration(hass, mock_config_entry)
state = hass.states.get("sensor.test_mower_1_cutting_blade_usage_time")
assert state is not None
assert state.state == "0.034"
assert float(state.state) == pytest.approx(0.03416666)
@pytest.mark.freeze_time(

9
tests/components/hydrawise/snapshots/test_sensor.ambr
View File

@ -78,6 +78,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -300,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -509,6 +515,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

111
tests/components/imeon_inverter/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -288,6 +300,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY_STORAGE: 'energy_storage'>,
'original_icon': None,
@ -341,6 +356,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -394,6 +412,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -447,6 +468,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -500,6 +524,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -553,6 +580,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -606,6 +636,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -659,6 +692,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -712,6 +748,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -765,6 +804,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -818,6 +860,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -871,6 +916,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -924,6 +972,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -977,6 +1028,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1030,6 +1084,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1083,6 +1140,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1136,6 +1196,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1914,6 +1977,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -1967,6 +2033,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2020,6 +2089,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2073,6 +2145,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -2126,6 +2201,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2179,6 +2257,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2232,6 +2313,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2285,6 +2369,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2338,6 +2425,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2391,6 +2481,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2444,6 +2537,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2497,6 +2593,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2550,6 +2649,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2603,6 +2705,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2656,6 +2761,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2709,6 +2817,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,

9
tests/components/incomfort/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -130,6 +136,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

6
tests/components/intellifire/snapshots/test_sensor.ambr
View File

@ -324,6 +324,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -378,6 +381,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

21
tests/components/iron_os/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -180,6 +186,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -233,6 +242,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -284,6 +296,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -646,6 +661,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -699,6 +717,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

6
tests/components/lcn/snapshots/test_sensor.ambr
View File

@ -117,6 +117,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -167,6 +170,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

26
tests/components/lektrico/snapshots/test_sensor.ambr
View File

@ -21,6 +21,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -73,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -124,6 +130,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -174,6 +183,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -226,6 +238,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -355,6 +370,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPower.KILO_WATT: 'kW'>,
}),
@ -384,7 +402,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.0000',
'state': '0.0',
})
# ---
# name: test_all_entities[sensor.1p7k_500006_state-entry]
@ -483,6 +501,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -534,6 +555,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

3
tests/components/letpot/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

6
tests/components/lg_thinq/snapshots/test_sensor.ambr
View File

@ -282,6 +282,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -332,6 +335,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

12
tests/components/madvr/snapshots/test_sensor.ambr
View File

@ -215,6 +215,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -268,6 +271,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -321,6 +327,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -834,6 +843,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

61
tests/components/matter/snapshots/test_sensor.ambr
View File

@ -617,6 +617,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -670,6 +673,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1160,6 +1166,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1266,6 +1275,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1564,6 +1576,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
@ -2133,6 +2148,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2235,6 +2253,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
@ -2264,7 +2285,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '3.050',
'state': '3.05',
})
# ---
# name: test_sensors[eve_weather_sensor][sensor.eve_weather_battery-entry]
@ -2453,6 +2474,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2506,6 +2530,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
@ -3024,6 +3051,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3077,6 +3107,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3130,6 +3163,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -3301,6 +3337,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -3406,6 +3445,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3459,6 +3501,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4849,6 +4894,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME_STORAGE: 'volume_storage'>,
'original_icon': None,
@ -5062,6 +5110,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfElectricPotential.VOLT: 'V'>,
}),
@ -5091,7 +5142,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.000',
'state': '0.0',
})
# ---
# name: test_sensors[solar_power][sensor.solarpower_current-entry]
@ -5354,6 +5405,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5407,6 +5461,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

15
tests/components/meteo_france/snapshots/test_sensor.ambr
View File

@ -177,6 +177,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -384,6 +387,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -540,6 +546,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -645,6 +654,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': 'mdi:weather-windy-variant',
@ -700,6 +712,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,

4
tests/components/metoffice/const.py
View File

@ -35,7 +35,7 @@ METOFFICE_CONFIG_KINGSLYNN = {
KINGSLYNN_SENSOR_RESULTS = {
"weather": "rainy",
"temperature": "7.87",
"temperature": "7.9",
"uv_index": "1",
"probability_of_precipitation": "67",
"pressure": "998.20",
@ -44,7 +44,7 @@ KINGSLYNN_SENSOR_RESULTS = {
WAVERTREE_SENSOR_RESULTS = {
"weather": "rainy",
"temperature": "9.28",
"temperature": "9.3",
"uv_index": "1",
"probability_of_precipitation": "61",
"pressure": "987.50",

18
tests/components/metoffice/test_sensor.py
View File

@ -24,13 +24,14 @@ from .const import (
WAVERTREE_SENSOR_RESULTS,
)
from tests.common import MockConfigEntry, load_fixture
from tests.common import MockConfigEntry, get_sensor_display_state, load_fixture
@pytest.mark.freeze_time(datetime.datetime(2024, 11, 23, 12, tzinfo=datetime.UTC))
async def test_one_sensor_site_running(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
) -> None:
"""Test the Met Office sensor platform."""
@ -69,7 +70,9 @@ async def test_one_sensor_site_running(
sensor_id = re.search("met_office_wavertree_(.+?)$", running_id).group(1)
sensor_value = WAVERTREE_SENSOR_RESULTS[sensor_id]
assert sensor.state == sensor_value
assert (
get_sensor_display_state(hass, entity_registry, running_id) == sensor_value
)
assert sensor.attributes.get("last_update").isoformat() == TEST_DATETIME_STRING
assert sensor.attributes.get("attribution") == ATTRIBUTION
@ -78,6 +81,7 @@ async def test_one_sensor_site_running(
async def test_two_sensor_sites_running(
hass: HomeAssistant,
device_registry: dr.DeviceRegistry,
entity_registry: er.EntityRegistry,
requests_mock: requests_mock.Mocker,
) -> None:
"""Test we handle two sets of sensors running for two different sites."""
@ -139,7 +143,10 @@ async def test_two_sensor_sites_running(
if "wavertree" in running_id:
sensor_id = re.search("met_office_wavertree_(.+?)$", running_id).group(1)
sensor_value = WAVERTREE_SENSOR_RESULTS[sensor_id]
assert sensor.state == sensor_value
assert (
get_sensor_display_state(hass, entity_registry, running_id)
== sensor_value
)
assert (
sensor.attributes.get("last_update").isoformat() == TEST_DATETIME_STRING
)
@ -148,7 +155,10 @@ async def test_two_sensor_sites_running(
else:
sensor_id = re.search("met_office_king_s_lynn_(.+?)$", running_id).group(1)
sensor_value = KINGSLYNN_SENSOR_RESULTS[sensor_id]
assert sensor.state == sensor_value
assert (
get_sensor_display_state(hass, entity_registry, running_id)
== sensor_value
)
assert (
sensor.attributes.get("last_update").isoformat() == TEST_DATETIME_STRING
)

36
tests/components/miele/snapshots/test_sensor.ambr
View File

@ -715,6 +715,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -950,6 +953,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1092,6 +1098,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1144,6 +1153,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1522,6 +1534,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1679,6 +1694,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,
@ -1872,6 +1890,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2107,6 +2128,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2249,6 +2273,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -2301,6 +2328,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2679,6 +2709,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -2836,6 +2869,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,

22
tests/components/mobile_app/test_sensor.py
View File

@ -26,8 +26,8 @@ from homeassistant.util.unit_system import (
@pytest.mark.parametrize(
("unit_system", "state_unit", "state1", "state2"),
[
(METRIC_SYSTEM, UnitOfTemperature.CELSIUS, "100", "123"),
(US_CUSTOMARY_SYSTEM, UnitOfTemperature.FAHRENHEIT, "212", "253"),
(METRIC_SYSTEM, UnitOfTemperature.CELSIUS, 100, 123),
(US_CUSTOMARY_SYSTEM, UnitOfTemperature.FAHRENHEIT, 212, 253.4),
],
)
async def test_sensor(
@ -83,7 +83,7 @@ async def test_sensor(
assert entity.attributes["state_class"] == "measurement"
assert entity.domain == "sensor"
assert entity.name == "Test 1 Battery Temperature"
assert entity.state == state1
assert float(entity.state) == state1
assert (
entity_registry.async_get("sensor.test_1_battery_temperature").entity_category
@ -113,7 +113,7 @@ async def test_sensor(
assert json["invalid_state"]["success"] is False
updated_entity = hass.states.get("sensor.test_1_battery_temperature")
assert updated_entity.state == state2
assert float(updated_entity.state) == state2
assert "foo" not in updated_entity.attributes
assert len(device_registry.devices) == len(create_registrations)
@ -135,21 +135,21 @@ async def test_sensor(
@pytest.mark.parametrize(
("unique_id", "unit_system", "state_unit", "state1", "state2"),
[
("battery_temperature", METRIC_SYSTEM, UnitOfTemperature.CELSIUS, "100", "123"),
("battery_temperature", METRIC_SYSTEM, UnitOfTemperature.CELSIUS, 100, 123),
(
"battery_temperature",
US_CUSTOMARY_SYSTEM,
UnitOfTemperature.FAHRENHEIT,
"212",
"253",
212,
253,
),
# The unique_id doesn't match that of the mobile app's battery temperature sensor
(
"battery_temp",
US_CUSTOMARY_SYSTEM,
UnitOfTemperature.FAHRENHEIT,
"212",
"123",
212,
123,
),
],
)
@ -205,7 +205,7 @@ async def test_sensor_migration(
assert entity.attributes["state_class"] == "measurement"
assert entity.domain == "sensor"
assert entity.name == "Test 1 Battery Temperature"
assert entity.state == state1
assert float(entity.state) == state1
# Reload to verify state is restored
config_entry = hass.config_entries.async_entries("mobile_app")[1]
@ -244,7 +244,7 @@ async def test_sensor_migration(
assert update_resp.status == HTTPStatus.OK
updated_entity = hass.states.get("sensor.test_1_battery_temperature")
assert updated_entity.state == state2
assert round(float(updated_entity.state), 0) == state2
assert "foo" not in updated_entity.attributes

6
tests/components/mqtt/test_sensor.py
View File

@ -1515,7 +1515,7 @@ async def test_cleanup_triggers_and_restoring_state(
await mqtt_mock_entry()
async_fire_mqtt_message(hass, "test-topic1", "100")
state = hass.states.get("sensor.test1")
assert state.state == "38" # 100 °F -> 38 °C
assert round(float(state.state)) == 38 # 100 °F -> 38 °C
async_fire_mqtt_message(hass, "test-topic2", "200")
state = hass.states.get("sensor.test2")
@ -1527,14 +1527,14 @@ async def test_cleanup_triggers_and_restoring_state(
await hass.async_block_till_done()
state = hass.states.get("sensor.test1")
assert state.state == "38" # 100 °F -> 38 °C
assert round(float(state.state)) == 38 # 100 °F -> 38 °C
state = hass.states.get("sensor.test2")
assert state.state == STATE_UNAVAILABLE
async_fire_mqtt_message(hass, "test-topic1", "80")
state = hass.states.get("sensor.test1")
assert state.state == "27" # 80 °F -> 27 °C
assert round(float(state.state)) == 27 # 80 °F -> 27 °C
async_fire_mqtt_message(hass, "test-topic2", "201")
state = hass.states.get("sensor.test2")

180
tests/components/myuplink/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -235,6 +247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -288,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -341,6 +359,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -394,6 +415,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -447,6 +471,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -500,6 +527,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -553,6 +583,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -606,6 +639,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -659,6 +695,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -712,6 +751,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -959,6 +1001,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1012,6 +1057,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1569,6 +1617,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1622,6 +1673,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1675,6 +1729,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1728,6 +1785,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1781,6 +1841,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1834,6 +1897,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1887,6 +1953,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1940,6 +2009,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1993,6 +2065,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2046,6 +2121,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2197,6 +2275,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2250,6 +2331,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2303,6 +2387,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2356,6 +2443,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2409,6 +2499,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2462,6 +2555,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2515,6 +2611,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2568,6 +2667,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2853,6 +2955,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2906,6 +3011,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2959,6 +3067,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3012,6 +3123,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3065,6 +3179,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -3118,6 +3235,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -3171,6 +3291,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -3224,6 +3347,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -3277,6 +3403,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3330,6 +3459,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3383,6 +3515,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3436,6 +3571,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3819,6 +3957,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME_FLOW_RATE: 'volume_flow_rate'>,
'original_icon': None,
@ -3872,6 +4013,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME_FLOW_RATE: 'volume_flow_rate'>,
'original_icon': None,
@ -3925,6 +4069,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3978,6 +4125,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4031,6 +4181,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4084,6 +4237,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4137,6 +4293,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4190,6 +4349,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4463,6 +4625,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4516,6 +4681,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4569,6 +4737,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4622,6 +4793,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4675,6 +4849,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4728,6 +4905,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

72
tests/components/netatmo/snapshots/test_sensor.ambr
View File

@ -264,6 +264,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -816,6 +819,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -1279,6 +1285,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1603,6 +1612,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -1715,6 +1727,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -1830,6 +1845,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -2001,6 +2019,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -2175,6 +2196,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -2287,6 +2311,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -2402,6 +2429,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -2573,6 +2603,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -2747,6 +2780,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -2859,6 +2895,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -2974,6 +3013,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -3145,6 +3187,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -3491,6 +3536,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -4350,6 +4398,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -4910,6 +4961,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -5278,6 +5332,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -6518,6 +6575,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6795,6 +6855,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WIND_SPEED: 'wind_speed'>,
'original_icon': None,
@ -6905,6 +6968,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SOUND_PRESSURE: 'sound_pressure'>,
'original_icon': None,
@ -7378,6 +7444,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,
@ -7489,6 +7558,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION: 'precipitation'>,
'original_icon': None,

6
tests/components/nexia/test_sensor.py
View File

@ -12,7 +12,7 @@ async def test_create_sensors(hass: HomeAssistant) -> None:
await async_init_integration(hass)
state = hass.states.get("sensor.nick_office_temperature")
assert state.state == "23"
assert round(float(state.state)) == 23
expected_attributes = {
"attribution": "Data provided by Trane Technologies",
@ -65,7 +65,7 @@ async def test_create_sensors(hass: HomeAssistant) -> None:
)
state = hass.states.get("sensor.master_suite_current_compressor_speed")
assert state.state == "69.0"
assert round(float(state.state)) == 69
expected_attributes = {
"attribution": "Data provided by Trane Technologies",
@ -79,7 +79,7 @@ async def test_create_sensors(hass: HomeAssistant) -> None:
)
state = hass.states.get("sensor.master_suite_outdoor_temperature")
assert state.state == "30.6"
assert round(float(state.state), 1) == 30.6
expected_attributes = {
"attribution": "Data provided by Trane Technologies",

3
tests/components/nextcloud/snapshots/test_sensor.ambr
View File

@ -3329,6 +3329,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

17
tests/components/nws/const.py
View File

@ -86,28 +86,32 @@ SENSOR_EXPECTED_OBSERVATION_IMPERIAL = {
round(
TemperatureConverter.convert(
5, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT
)
),
1,
)
),
"temperature": str(
round(
TemperatureConverter.convert(
10, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT
)
),
1,
)
),
"windChill": str(
round(
TemperatureConverter.convert(
5, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT
)
),
1,
)
),
"heatIndex": str(
round(
TemperatureConverter.convert(
15, UnitOfTemperature.CELSIUS, UnitOfTemperature.FAHRENHEIT
)
),
1,
)
),
"relativeHumidity": "10",
@ -115,14 +119,14 @@ SENSOR_EXPECTED_OBSERVATION_IMPERIAL = {
round(
SpeedConverter.convert(
10, UnitOfSpeed.KILOMETERS_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR
)
),
)
),
"windGust": str(
round(
SpeedConverter.convert(
20, UnitOfSpeed.KILOMETERS_PER_HOUR, UnitOfSpeed.MILES_PER_HOUR
)
),
)
),
"windDirection": "180",
@ -234,5 +238,4 @@ EXPECTED_FORECAST_METRIC = {
),
ATTR_FORECAST_HUMIDITY: 75,
}
NONE_FORECAST = [dict.fromkeys(DEFAULT_FORECAST[0])]

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

@ -66,7 +66,9 @@ async def test_imperial_metric(
assert description.name
state = hass.states.get(f"sensor.abc_{slugify(description.name)}")
assert state
assert state.state == result_observation[description.key]
assert state.state == result_observation[description.key], (
f"Failed for {description.key}"
)
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION

12
tests/components/nyt_games/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -438,6 +444,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -491,6 +500,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

6
tests/components/nzbget/test_sensor.py
View File

@ -36,14 +36,14 @@ async def test_sensors(hass: HomeAssistant, entity_registry: er.EntityRegistry)
),
"average_speed": (
"AverageDownloadRate",
"1.250000",
"1.25",
UnitOfDataRate.MEGABYTES_PER_SECOND,
SensorDeviceClass.DATA_RATE,
),
"download_paused": ("DownloadPaused", "False", None, None),
"speed": (
"DownloadRate",
"2.500000",
"2.5",
UnitOfDataRate.MEGABYTES_PER_SECOND,
SensorDeviceClass.DATA_RATE,
),
@ -70,7 +70,7 @@ async def test_sensors(hass: HomeAssistant, entity_registry: er.EntityRegistry)
"uptime": ("UpTimeSec", uptime.isoformat(), None, SensorDeviceClass.TIMESTAMP),
"speed_limit": (
"DownloadLimit",
"1.000000",
"1.0",
UnitOfDataRate.MEGABYTES_PER_SECOND,
SensorDeviceClass.DATA_RATE,
),

9
tests/components/ohme/snapshots/test_sensor.ambr
View File

@ -69,6 +69,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -119,6 +122,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -405,6 +411,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

10
tests/components/omnilogic/snapshots/test_sensor.ambr
View File

@ -21,6 +21,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -48,7 +51,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '21',
'state': '21.1111111111111',
})
# ---
# name: test_sensors[sensor.scrubbed_spa_water_temperature-entry]
@ -73,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -100,6 +106,6 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '22',
'state': '21.6666666666667',
})
# ---

6
tests/components/ondilo_ico/snapshots/test_sensor.ambr
View File

@ -336,6 +336,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -702,6 +705,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

114
tests/components/onewire/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -78,6 +81,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -133,6 +139,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -294,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -349,6 +361,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -404,6 +419,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -459,6 +477,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -514,6 +535,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -569,6 +593,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -624,6 +651,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -679,6 +709,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -734,6 +767,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1119,6 +1155,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -1174,6 +1213,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1229,6 +1271,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1284,6 +1329,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1339,6 +1387,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1394,6 +1445,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1449,6 +1503,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1504,6 +1561,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1559,6 +1619,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1614,6 +1677,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1669,6 +1735,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1724,6 +1793,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1779,6 +1851,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1834,6 +1909,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1999,6 +2077,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -2054,6 +2135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2109,6 +2193,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -2164,6 +2251,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2549,6 +2639,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -2604,6 +2697,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2659,6 +2755,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2714,6 +2813,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2769,6 +2871,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -2934,6 +3039,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2989,6 +3097,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -3044,6 +3155,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,

52
tests/components/openweathermap/snapshots/test_sensor.ambr
View File

@ -125,6 +125,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -179,6 +182,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -336,6 +342,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -390,6 +399,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION_INTENSITY: 'precipitation_intensity'>,
'original_icon': None,
@ -444,6 +456,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION_INTENSITY: 'precipitation_intensity'>,
'original_icon': None,
@ -498,6 +513,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -605,6 +623,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -811,6 +832,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
}),
@ -841,7 +865,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '35.39',
'state': '35.388',
})
# ---
# name: test_sensor_states[v3.0][sensor.openweathermap_cloud_coverage-entry]
@ -970,6 +994,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1024,6 +1051,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1181,6 +1211,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -1235,6 +1268,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION_INTENSITY: 'precipitation_intensity'>,
'original_icon': None,
@ -1289,6 +1325,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PRECIPITATION_INTENSITY: 'precipitation_intensity'>,
'original_icon': None,
@ -1343,6 +1382,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1450,6 +1492,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -1656,6 +1701,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfSpeed.KILOMETERS_PER_HOUR: 'km/h'>,
}),
@ -1686,6 +1734,6 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '35.39',
'state': '35.388',
})
# ---

24
tests/components/palazzetti/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WEIGHT: 'weight'>,
'original_icon': None,
@ -235,6 +247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -288,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -489,6 +507,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -542,6 +563,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

6
tests/components/paperless_ngx/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -748,6 +751,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,

21
tests/components/peblar/snapshots/test_sensor.ambr
View File

@ -406,6 +406,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -459,6 +462,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -512,6 +518,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -565,6 +574,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -794,6 +806,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -847,6 +862,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -900,6 +918,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

9
tests/components/ping/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -75,6 +78,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -133,6 +139,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,

3
tests/components/plaato/snapshots/test_sensor.ambr
View File

@ -565,6 +565,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

3
tests/components/poolsense/snapshots/test_sensor.ambr
View File

@ -420,6 +420,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

30
tests/components/powerfox/snapshots/test_sensor.ambr
View File

@ -21,6 +21,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -126,6 +129,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -179,6 +185,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,
@ -232,6 +241,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -285,6 +297,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -338,6 +353,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -391,6 +409,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -444,6 +465,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -497,6 +521,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,
@ -550,6 +577,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,

9
tests/components/rainforest_raven/snapshots/test_sensor.ambr
View File

@ -77,6 +77,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -183,6 +186,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -236,6 +242,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,

39
tests/components/rehlko/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -177,6 +183,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -230,6 +239,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -283,6 +295,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -336,6 +351,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPressure.KPA: 'kPa'>,
}),
@ -492,6 +510,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -792,6 +813,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -991,6 +1015,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1092,6 +1119,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1145,6 +1175,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1198,6 +1231,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1251,6 +1287,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

138
tests/components/renault/snapshots/test_sensor.ambr
View File

@ -76,6 +76,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -129,6 +132,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -182,6 +188,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -305,6 +314,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -358,6 +370,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -558,6 +573,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -611,6 +629,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -781,6 +802,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -834,6 +858,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -887,6 +914,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1010,6 +1040,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1063,6 +1096,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -1263,6 +1299,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -1316,6 +1355,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1433,6 +1475,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -1486,6 +1531,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME: 'volume'>,
'original_icon': None,
@ -1588,6 +1636,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -1737,6 +1788,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1843,6 +1897,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -1896,6 +1953,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1949,6 +2009,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2072,6 +2135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -2125,6 +2191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -2178,6 +2247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.VOLUME: 'volume'>,
'original_icon': None,
@ -2329,6 +2401,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -2542,6 +2617,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2648,6 +2726,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -2701,6 +2782,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2754,6 +2838,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2877,6 +2964,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -3126,6 +3216,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -3179,6 +3272,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3349,6 +3445,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -3402,6 +3501,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -3455,6 +3557,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3578,6 +3683,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3631,6 +3739,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -3831,6 +3942,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -3884,6 +3998,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4001,6 +4118,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4107,6 +4227,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -4160,6 +4283,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -4213,6 +4339,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4336,6 +4465,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -4585,6 +4717,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,
@ -4638,6 +4773,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

12
tests/components/sabnzbd/snapshots/test_sensor.ambr
View File

@ -79,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -132,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -297,6 +303,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -511,6 +520,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,

3
tests/components/sanix/snapshots/test_sensor.ambr
View File

@ -124,6 +124,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DISTANCE: 'distance'>,
'original_icon': None,

93
tests/components/sense/snapshots/test_sensor.ambr
View File

@ -197,6 +197,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': 'mdi:car-electric',
@ -542,6 +545,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': 'mdi:stove',
@ -713,6 +719,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -768,6 +777,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -823,6 +835,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -928,6 +943,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1033,6 +1051,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1088,6 +1109,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1143,6 +1167,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1198,6 +1225,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1303,6 +1333,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1408,6 +1441,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1463,6 +1499,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1517,6 +1556,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1571,6 +1613,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1625,6 +1670,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1680,6 +1728,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1735,6 +1786,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1840,6 +1894,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1945,6 +2002,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2000,6 +2060,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2054,6 +2117,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2109,6 +2175,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2164,6 +2233,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2269,6 +2341,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2374,6 +2449,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2429,6 +2507,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2484,6 +2565,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2539,6 +2623,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2644,6 +2731,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2749,6 +2839,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,

15
tests/components/sensibo/snapshots/test_sensor.ambr
View File

@ -180,6 +180,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -241,6 +244,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -399,6 +405,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -558,6 +567,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -611,6 +623,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

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

@ -31,12 +31,25 @@ from homeassistant.const import (
PERCENTAGE,
STATE_UNKNOWN,
EntityCategory,
UnitOfApparentPower,
UnitOfArea,
UnitOfBloodGlucoseConcentration,
UnitOfConductivity,
UnitOfDataRate,
UnitOfElectricCurrent,
UnitOfElectricPotential,
UnitOfEnergy,
UnitOfEnergyDistance,
UnitOfFrequency,
UnitOfInformation,
UnitOfIrradiance,
UnitOfLength,
UnitOfMass,
UnitOfPower,
UnitOfPrecipitationDepth,
UnitOfPressure,
UnitOfReactivePower,
UnitOfSoundPressure,
UnitOfSpeed,
UnitOfTemperature,
UnitOfTime,
@ -78,28 +91,28 @@ TEST_DOMAIN = "test"
UnitOfTemperature.FAHRENHEIT,
UnitOfTemperature.FAHRENHEIT,
100,
"100",
100,
),
(
US_CUSTOMARY_SYSTEM,
UnitOfTemperature.CELSIUS,
UnitOfTemperature.FAHRENHEIT,
38,
"100",
100.4,
),
(
METRIC_SYSTEM,
UnitOfTemperature.FAHRENHEIT,
UnitOfTemperature.CELSIUS,
100,
"38",
pytest.approx(37.77778),
),
(
METRIC_SYSTEM,
UnitOfTemperature.CELSIUS,
UnitOfTemperature.CELSIUS,
38,
"38",
38,
),
],
)
@ -125,7 +138,7 @@ async def test_temperature_conversion(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == state_value
assert float(state.state) == state_value
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == state_unit
@ -593,6 +606,8 @@ async def test_unit_translation_key_without_platform_raises(
"state_unit",
"native_value",
"custom_state",
"rounded_state",
"suggested_precision",
),
[
# Smaller to larger unit, InHg is ~33x larger than hPa -> 1 more decimal
@ -602,7 +617,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.INHG,
UnitOfPressure.INHG,
1000.0,
pytest.approx(29.52998),
"29.53",
2,
),
(
SensorDeviceClass.PRESSURE,
@ -610,7 +627,19 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.HPA,
UnitOfPressure.HPA,
1.234,
"12.340",
12.34,
"12.34",
2,
),
(
SensorDeviceClass.PRESSURE,
UnitOfPressure.HPA,
UnitOfPressure.PA,
UnitOfPressure.PA,
1.234,
123.4,
"123",
0,
),
(
SensorDeviceClass.ATMOSPHERIC_PRESSURE,
@ -618,7 +647,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.MMHG,
UnitOfPressure.MMHG,
1000,
"750",
pytest.approx(750.061575),
"750.06",
2,
),
(
SensorDeviceClass.PRESSURE,
@ -626,7 +657,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.MMHG,
UnitOfPressure.MMHG,
1000,
"750",
pytest.approx(750.061575),
"750.06",
2,
),
# Not a supported pressure unit
(
@ -635,7 +668,9 @@ async def test_unit_translation_key_without_platform_raises(
"peer_pressure",
UnitOfPressure.HPA,
1000,
"1000",
1000,
"1000.00",
2,
),
(
SensorDeviceClass.TEMPERATURE,
@ -643,7 +678,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfTemperature.FAHRENHEIT,
UnitOfTemperature.FAHRENHEIT,
37.5,
99.5,
"99.5",
1,
),
(
SensorDeviceClass.TEMPERATURE,
@ -651,7 +688,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfTemperature.CELSIUS,
UnitOfTemperature.CELSIUS,
100,
"38",
pytest.approx(37.77777),
"37.8",
1,
),
(
SensorDeviceClass.ATMOSPHERIC_PRESSURE,
@ -659,7 +698,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.HPA,
UnitOfPressure.HPA,
-0.00,
"0.0",
0.0,
"0.00",
2,
),
(
SensorDeviceClass.ATMOSPHERIC_PRESSURE,
@ -667,7 +708,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfPressure.HPA,
UnitOfPressure.HPA,
-0.00001,
"0",
pytest.approx(-0.0003386388),
"0.00",
2,
),
(
SensorDeviceClass.VOLUME_FLOW_RATE,
@ -675,7 +718,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfVolumeFlowRate.GALLONS_PER_MINUTE,
UnitOfVolumeFlowRate.GALLONS_PER_MINUTE,
50.0,
"13.2",
pytest.approx(13.208602),
"13",
0,
),
(
SensorDeviceClass.VOLUME_FLOW_RATE,
@ -683,7 +728,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfVolumeFlowRate.LITERS_PER_MINUTE,
UnitOfVolumeFlowRate.LITERS_PER_MINUTE,
13.0,
"49.2",
pytest.approx(49.2103531),
"49",
0,
),
(
SensorDeviceClass.DURATION,
@ -691,7 +738,9 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfTime.HOURS,
UnitOfTime.HOURS,
5400.0,
"1.5000",
1.5,
"1.50",
2,
),
(
SensorDeviceClass.DURATION,
@ -699,7 +748,29 @@ async def test_unit_translation_key_without_platform_raises(
UnitOfTime.MINUTES,
UnitOfTime.MINUTES,
0.5,
"720.0",
720,
"720.00",
2,
),
(
SensorDeviceClass.BLOOD_GLUCOSE_CONCENTRATION,
UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER,
UnitOfBloodGlucoseConcentration.MILLIMOLE_PER_LITER,
UnitOfBloodGlucoseConcentration.MILLIMOLE_PER_LITER,
130,
pytest.approx(7.222222),
"7.2",
1,
),
(
SensorDeviceClass.ENERGY,
UnitOfEnergy.WATT_HOUR,
UnitOfEnergy.KILO_WATT_HOUR,
UnitOfEnergy.KILO_WATT_HOUR,
1.1,
0.0011,
"0.00",
2,
),
],
)
@ -712,6 +783,8 @@ async def test_custom_unit(
state_unit,
native_value,
custom_state,
rounded_state,
suggested_precision,
) -> None:
"""Test custom unit."""
entry = entity_registry.async_get_or_create("sensor", "test", "very_unique")
@ -734,13 +807,17 @@ async def test_custom_unit(
entity_id = entity0.entity_id
state = hass.states.get(entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == state_unit
assert (
async_rounded_state(hass, entity_id, hass.states.get(entity_id)) == custom_state
async_rounded_state(hass, entity_id, hass.states.get(entity_id))
== rounded_state
)
entry = entity_registry.async_get(entity0.entity_id)
assert entry.options["sensor"]["suggested_display_precision"] == suggested_precision
@pytest.mark.parametrize(
(
@ -759,8 +836,8 @@ async def test_custom_unit(
UnitOfArea.SQUARE_MILES,
UnitOfArea.SQUARE_MILES,
1000,
"1000",
"386",
1000,
pytest.approx(386.102),
SensorDeviceClass.AREA,
),
(
@ -768,8 +845,8 @@ async def test_custom_unit(
UnitOfArea.SQUARE_INCHES,
UnitOfArea.SQUARE_INCHES,
7.24,
"7.24",
"1.12",
7.24,
pytest.approx(1.1222022),
SensorDeviceClass.AREA,
),
(
@ -777,8 +854,8 @@ async def test_custom_unit(
"peer_distance",
UnitOfArea.SQUARE_KILOMETERS,
1000,
"1000",
"1000",
1000,
1000,
SensorDeviceClass.AREA,
),
# Distance
@ -787,8 +864,8 @@ async def test_custom_unit(
UnitOfLength.MILES,
UnitOfLength.MILES,
1000,
"1000",
"621",
1000,
pytest.approx(621.371),
SensorDeviceClass.DISTANCE,
),
(
@ -796,8 +873,8 @@ async def test_custom_unit(
UnitOfLength.INCHES,
UnitOfLength.INCHES,
7.24,
"7.24",
"2.85",
7.24,
pytest.approx(2.8503937),
SensorDeviceClass.DISTANCE,
),
(
@ -805,8 +882,8 @@ async def test_custom_unit(
"peer_distance",
UnitOfLength.KILOMETERS,
1000,
"1000",
"1000",
1000,
1000,
SensorDeviceClass.DISTANCE,
),
# Energy
@ -815,8 +892,8 @@ async def test_custom_unit(
UnitOfEnergy.MEGA_WATT_HOUR,
UnitOfEnergy.MEGA_WATT_HOUR,
1000,
"1000",
"1.000",
1000,
1.000,
SensorDeviceClass.ENERGY,
),
(
@ -824,8 +901,8 @@ async def test_custom_unit(
UnitOfEnergy.MEGA_WATT_HOUR,
UnitOfEnergy.MEGA_WATT_HOUR,
1000,
"1000",
"278",
1000,
pytest.approx(277.7778),
SensorDeviceClass.ENERGY,
),
(
@ -833,8 +910,8 @@ async def test_custom_unit(
"BTU",
UnitOfEnergy.KILO_WATT_HOUR,
1000,
"1000",
"1000",
1000,
1000,
SensorDeviceClass.ENERGY,
),
# Power factor
@ -843,8 +920,8 @@ async def test_custom_unit(
PERCENTAGE,
PERCENTAGE,
1.0,
"1.0",
"100.0",
1.0,
100.0,
SensorDeviceClass.POWER_FACTOR,
),
(
@ -852,8 +929,8 @@ async def test_custom_unit(
None,
None,
100,
"100",
"1.00",
100,
1.00,
SensorDeviceClass.POWER_FACTOR,
),
(
@ -861,8 +938,8 @@ async def test_custom_unit(
None,
"Cos φ",
1.0,
"1.0",
"1.0",
1.0,
1.0,
SensorDeviceClass.POWER_FACTOR,
),
# Pressure
@ -872,8 +949,8 @@ async def test_custom_unit(
UnitOfPressure.INHG,
UnitOfPressure.INHG,
1000.0,
"1000.0",
"29.53",
1000.0,
pytest.approx(29.52998),
SensorDeviceClass.PRESSURE,
),
(
@ -881,8 +958,8 @@ async def test_custom_unit(
UnitOfPressure.HPA,
UnitOfPressure.HPA,
1.234,
"1.234",
"12.340",
1.234,
12.340,
SensorDeviceClass.PRESSURE,
),
(
@ -890,8 +967,8 @@ async def test_custom_unit(
UnitOfPressure.MMHG,
UnitOfPressure.MMHG,
1000,
"1000",
"750",
1000,
pytest.approx(750.0615),
SensorDeviceClass.PRESSURE,
),
# Not a supported pressure unit
@ -900,8 +977,8 @@ async def test_custom_unit(
"peer_pressure",
UnitOfPressure.HPA,
1000,
"1000",
"1000",
1000,
1000,
SensorDeviceClass.PRESSURE,
),
# Speed
@ -910,8 +987,8 @@ async def test_custom_unit(
UnitOfSpeed.MILES_PER_HOUR,
UnitOfSpeed.MILES_PER_HOUR,
100,
"100",
"62",
100,
pytest.approx(62.1371),
SensorDeviceClass.SPEED,
),
(
@ -919,8 +996,8 @@ async def test_custom_unit(
UnitOfVolumetricFlux.INCHES_PER_HOUR,
UnitOfVolumetricFlux.INCHES_PER_HOUR,
78,
"78",
"0.13",
78,
pytest.approx(0.127952755),
SensorDeviceClass.SPEED,
),
(
@ -928,8 +1005,8 @@ async def test_custom_unit(
"peer_distance",
UnitOfSpeed.KILOMETERS_PER_HOUR,
100,
"100",
"100",
100,
100,
SensorDeviceClass.SPEED,
),
# Volume
@ -938,8 +1015,8 @@ async def test_custom_unit(
UnitOfVolume.CUBIC_FEET,
UnitOfVolume.CUBIC_FEET,
100,
"100",
"3531",
100,
pytest.approx(3531.4667),
SensorDeviceClass.VOLUME,
),
(
@ -947,8 +1024,8 @@ async def test_custom_unit(
UnitOfVolume.FLUID_OUNCES,
UnitOfVolume.FLUID_OUNCES,
2.3,
"2.3",
"77.8",
2.3,
pytest.approx(77.77225),
SensorDeviceClass.VOLUME,
),
(
@ -956,8 +1033,8 @@ async def test_custom_unit(
"peer_distance",
UnitOfVolume.CUBIC_METERS,
100,
"100",
"100",
100,
100,
SensorDeviceClass.VOLUME,
),
# Weight
@ -966,8 +1043,8 @@ async def test_custom_unit(
UnitOfMass.OUNCES,
UnitOfMass.OUNCES,
100,
"100",
"3.5",
100,
pytest.approx(3.5273962),
SensorDeviceClass.WEIGHT,
),
(
@ -975,8 +1052,8 @@ async def test_custom_unit(
UnitOfMass.GRAMS,
UnitOfMass.GRAMS,
78,
"78",
"2211",
78,
pytest.approx(2211.262),
SensorDeviceClass.WEIGHT,
),
(
@ -984,8 +1061,8 @@ async def test_custom_unit(
"peer_distance",
UnitOfMass.GRAMS,
100,
"100",
"100",
100,
100,
SensorDeviceClass.WEIGHT,
),
],
@ -1015,7 +1092,7 @@ async def test_custom_unit_change(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == native_state
assert float(state.state) == native_state
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == native_unit
entity_registry.async_update_entity_options(
@ -1024,7 +1101,7 @@ async def test_custom_unit_change(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == state_unit
entity_registry.async_update_entity_options(
@ -1033,14 +1110,14 @@ async def test_custom_unit_change(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == native_state
assert float(state.state) == native_state
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == native_unit
entity_registry.async_update_entity_options("sensor.test", "sensor", None)
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == native_state
assert float(state.state) == native_state
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == native_unit
@ -1067,10 +1144,10 @@ async def test_custom_unit_change(
UnitOfLength.METERS,
UnitOfLength.YARDS,
1000,
"1000",
"621",
"1000000",
"1093613",
1000,
pytest.approx(621.371),
1000000,
pytest.approx(1093613),
SensorDeviceClass.DISTANCE,
),
# Volume Storage (subclass of Volume)
@ -1081,10 +1158,10 @@ async def test_custom_unit_change(
UnitOfVolume.GALLONS,
UnitOfVolume.FLUID_OUNCES,
1000,
"1000",
"264",
"264",
"33814",
1000,
pytest.approx(264.172),
pytest.approx(264.172),
pytest.approx(33814.022),
SensorDeviceClass.VOLUME_STORAGE,
),
],
@ -1152,34 +1229,36 @@ async def test_unit_conversion_priority(
# Registered entity -> Follow automatic unit conversion
state = hass.states.get(entity0.entity_id)
assert state.state == automatic_state
assert float(state.state) == automatic_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit
# Assert the automatic unit conversion is stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.unit_of_measurement == automatic_unit
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": automatic_unit}
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== automatic_unit
)
# Unregistered entity -> Follow native unit
state = hass.states.get(entity1.entity_id)
assert state.state == native_state
assert float(state.state) == native_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == native_unit
# Registered entity with suggested unit
state = hass.states.get(entity2.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity2.entity_id)
assert entry.unit_of_measurement == suggested_unit
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": suggested_unit}
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== suggested_unit
)
# Unregistered entity with suggested unit
state = hass.states.get(entity3.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Set a custom unit, this should have priority over the automatic unit conversion
@ -1189,7 +1268,7 @@ async def test_unit_conversion_priority(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
entity_registry.async_update_entity_options(
@ -1198,7 +1277,7 @@ async def test_unit_conversion_priority(
await hass.async_block_till_done()
state = hass.states.get(entity2.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
@ -1387,7 +1466,6 @@ async def test_unit_conversion_priority_precision(
{"display_precision": 4},
)
entry4 = entity_registry.async_get(entity4.entity_id)
assert "suggested_display_precision" not in entry4.options["sensor"]
assert entry4.options["sensor"]["display_precision"] == 4
await hass.async_block_till_done()
state = hass.states.get(entity4.entity_id)
@ -1479,9 +1557,10 @@ async def test_unit_conversion_priority_suggested_unit_change(
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.unit_of_measurement == original_unit
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": original_unit},
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== original_unit
)
# Registered entity -> Follow suggested unit the first time the entity was seen
state = hass.states.get(entity1.entity_id)
@ -1490,9 +1569,10 @@ async def test_unit_conversion_priority_suggested_unit_change(
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity1.entity_id)
assert entry.unit_of_measurement == original_unit
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": original_unit},
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== original_unit
)
@pytest.mark.parametrize(
@ -1574,9 +1654,10 @@ async def test_unit_conversion_priority_suggested_unit_change_2(
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.unit_of_measurement == native_unit_1
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": native_unit_1},
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== native_unit_1
)
# Registered entity -> Follow unit in entity registry
state = hass.states.get(entity1.entity_id)
@ -1585,9 +1666,89 @@ async def test_unit_conversion_priority_suggested_unit_change_2(
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.unit_of_measurement == native_unit_1
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": native_unit_1},
}
assert (
entry.options["sensor.private"]["suggested_unit_of_measurement"]
== native_unit_1
)
@pytest.mark.parametrize(
(
"device_class",
"native_unit",
"suggested_precision",
),
[
(SensorDeviceClass.APPARENT_POWER, UnitOfApparentPower.VOLT_AMPERE, 0),
(SensorDeviceClass.AREA, UnitOfArea.SQUARE_CENTIMETERS, 0),
(SensorDeviceClass.ATMOSPHERIC_PRESSURE, UnitOfPressure.PA, 0),
(
SensorDeviceClass.BLOOD_GLUCOSE_CONCENTRATION,
UnitOfBloodGlucoseConcentration.MILLIGRAMS_PER_DECILITER,
0,
),
(SensorDeviceClass.CONDUCTIVITY, UnitOfConductivity.MICROSIEMENS, 1),
(SensorDeviceClass.CURRENT, UnitOfElectricCurrent.MILLIAMPERE, 0),
(SensorDeviceClass.DATA_RATE, UnitOfDataRate.KILOBITS_PER_SECOND, 0),
(SensorDeviceClass.DATA_SIZE, UnitOfInformation.KILOBITS, 0),
(SensorDeviceClass.DISTANCE, UnitOfLength.CENTIMETERS, 0),
(SensorDeviceClass.DURATION, UnitOfTime.MILLISECONDS, 0),
(SensorDeviceClass.ENERGY, UnitOfEnergy.WATT_HOUR, 0),
(
SensorDeviceClass.ENERGY_DISTANCE,
UnitOfEnergyDistance.KM_PER_KILO_WATT_HOUR,
0,
),
(SensorDeviceClass.ENERGY_STORAGE, UnitOfEnergy.WATT_HOUR, 0),
(SensorDeviceClass.FREQUENCY, UnitOfFrequency.HERTZ, 0),
(SensorDeviceClass.GAS, UnitOfVolume.MILLILITERS, 0),
(SensorDeviceClass.IRRADIANCE, UnitOfIrradiance.WATTS_PER_SQUARE_METER, 0),
(SensorDeviceClass.POWER, UnitOfPower.WATT, 0),
(SensorDeviceClass.PRECIPITATION, UnitOfPrecipitationDepth.CENTIMETERS, 0),
(
SensorDeviceClass.PRECIPITATION_INTENSITY,
UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
0,
),
(SensorDeviceClass.PRESSURE, UnitOfPressure.PA, 0),
(SensorDeviceClass.REACTIVE_POWER, UnitOfReactivePower.VOLT_AMPERE_REACTIVE, 0),
(SensorDeviceClass.SOUND_PRESSURE, UnitOfSoundPressure.DECIBEL, 0),
(SensorDeviceClass.SPEED, UnitOfSpeed.MILLIMETERS_PER_SECOND, 0),
(SensorDeviceClass.TEMPERATURE, UnitOfTemperature.KELVIN, 1),
(SensorDeviceClass.VOLTAGE, UnitOfElectricPotential.VOLT, 0),
(SensorDeviceClass.VOLUME, UnitOfVolume.MILLILITERS, 0),
(SensorDeviceClass.VOLUME_FLOW_RATE, UnitOfVolumeFlowRate.LITERS_PER_SECOND, 0),
(SensorDeviceClass.VOLUME_STORAGE, UnitOfVolume.MILLILITERS, 0),
(SensorDeviceClass.WATER, UnitOfVolume.MILLILITERS, 0),
(SensorDeviceClass.WEIGHT, UnitOfMass.GRAMS, 0),
(SensorDeviceClass.WIND_SPEED, UnitOfSpeed.MILLIMETERS_PER_SECOND, 0),
],
)
async def test_default_precision(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
device_class: str,
native_unit: str,
suggested_precision: int,
) -> None:
"""Test default unit precision."""
entry = entity_registry.async_get_or_create("sensor", "test", "very_unique")
await hass.async_block_till_done()
entity0 = MockSensor(
name="Test",
native_value="123",
native_unit_of_measurement=native_unit,
device_class=device_class,
unique_id="very_unique",
)
setup_test_component_platform(hass, sensor.DOMAIN, [entity0])
assert await async_setup_component(hass, "sensor", {"sensor": {"platform": "test"}})
await hass.async_block_till_done()
entry = entity_registry.async_get(entity0.entity_id)
assert entry.options["sensor"]["suggested_display_precision"] == suggested_precision
@pytest.mark.parametrize(
@ -1756,39 +1917,6 @@ async def test_suggested_precision_option_update(
}
async def test_suggested_precision_option_removal(
hass: HomeAssistant,
entity_registry: er.EntityRegistry,
) -> None:
"""Test suggested precision stored in the registry is removed."""
# Pre-register entities
entry = entity_registry.async_get_or_create("sensor", "test", "very_unique")
entity_registry.async_update_entity_options(
entry.entity_id,
"sensor",
{
"suggested_display_precision": 1,
},
)
entity0 = MockSensor(
name="Test",
device_class=SensorDeviceClass.DURATION,
native_unit_of_measurement=UnitOfTime.HOURS,
native_value="1.5",
suggested_display_precision=None,
unique_id="very_unique",
)
setup_test_component_platform(hass, sensor.DOMAIN, [entity0])
assert await async_setup_component(hass, "sensor", {"sensor": {"platform": "test"}})
await hass.async_block_till_done()
# Assert the suggested precision is no longer stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.options.get("sensor", {}).get("suggested_display_precision") is None
@pytest.mark.parametrize(
(
"unit_system",
@ -1805,7 +1933,7 @@ async def test_suggested_precision_option_removal(
UnitOfLength.KILOMETERS,
UnitOfLength.MILES,
1000,
621.0,
621.3711,
SensorDeviceClass.DISTANCE,
),
(
@ -2346,10 +2474,10 @@ async def test_numeric_state_expected_helper(
UnitOfLength.METERS,
UnitOfLength.YARDS,
1000,
"621",
"1000",
"1000000",
"1093613",
pytest.approx(621.3711),
1000,
1000000,
pytest.approx(1093613),
SensorDeviceClass.DISTANCE,
),
],
@ -2439,40 +2567,40 @@ async def test_unit_conversion_update(
# Registered entity -> Follow automatic unit conversion
state = hass.states.get(entity0.entity_id)
assert state.state == automatic_state_1
assert float(state.state) == automatic_state_1
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit_1
# Assert the automatic unit conversion is stored in the registry
entry = entity_registry.async_get(entity0.entity_id)
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": automatic_unit_1}
assert entry.options["sensor.private"] == {
"suggested_unit_of_measurement": automatic_unit_1
}
state = hass.states.get(entity1.entity_id)
assert state.state == automatic_state_1
assert float(state.state) == automatic_state_1
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit_1
# Assert the automatic unit conversion is stored in the registry
entry = entity_registry.async_get(entity1.entity_id)
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": automatic_unit_1}
assert entry.options["sensor.private"] == {
"suggested_unit_of_measurement": automatic_unit_1
}
# Registered entity with suggested unit
state = hass.states.get(entity2.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity2.entity_id)
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": suggested_unit}
assert entry.options["sensor.private"] == {
"suggested_unit_of_measurement": suggested_unit
}
state = hass.states.get(entity3.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Assert the suggested unit is stored in the registry
entry = entity_registry.async_get(entity3.entity_id)
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": suggested_unit}
assert entry.options["sensor.private"] == {
"suggested_unit_of_measurement": suggested_unit
}
# Set a custom unit, this should have priority over the automatic unit conversion
@ -2482,7 +2610,7 @@ async def test_unit_conversion_update(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
entity_registry.async_update_entity_options(
@ -2491,7 +2619,7 @@ async def test_unit_conversion_update(
await hass.async_block_till_done()
state = hass.states.get(entity2.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
# Change unit system, states and units should be unchanged
@ -2499,19 +2627,19 @@ async def test_unit_conversion_update(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
state = hass.states.get(entity1.entity_id)
assert state.state == automatic_state_1
assert float(state.state) == automatic_state_1
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit_1
state = hass.states.get(entity2.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
state = hass.states.get(entity3.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Update suggested unit
@ -2522,39 +2650,37 @@ async def test_unit_conversion_update(
await hass.async_block_till_done()
state = hass.states.get(entity0.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
state = hass.states.get(entity1.entity_id)
assert state.state == automatic_state_2
assert float(state.state) == automatic_state_2
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit_2
state = hass.states.get(entity2.entity_id)
assert state.state == custom_state
assert float(state.state) == custom_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == custom_unit
state = hass.states.get(entity3.entity_id)
assert state.state == suggested_state
assert float(state.state) == suggested_state
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == suggested_unit
# Entity 4 still has a pending request to refresh entity options
entry = entity_registry.async_get(entity4_entity_id)
assert entry.options == {
"sensor.private": {
"refresh_initial_entity_options": True,
"suggested_unit_of_measurement": automatic_unit_1,
}
assert entry.options["sensor.private"] == {
"refresh_initial_entity_options": True,
"suggested_unit_of_measurement": automatic_unit_1,
}
# Add entity 4, the pending request to refresh entity options should be handled
await entity_platform.async_add_entities((entity4,))
state = hass.states.get(entity4_entity_id)
assert state.state == automatic_state_2
assert float(state.state) == automatic_state_2
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == automatic_unit_2
entry = entity_registry.async_get(entity4_entity_id)
assert entry.options == {}
assert "sensor.private" not in entry.options
class MockFlow(ConfigFlow):
@ -2763,7 +2889,7 @@ async def test_suggested_unit_guard_invalid_unit(
UnitOfTemperature.CELSIUS,
10,
UnitOfTemperature.KELVIN,
283,
283.15,
),
(
SensorDeviceClass.DATA_RATE,
@ -2809,8 +2935,8 @@ async def test_suggested_unit_guard_valid_unit(
# Assert the suggested unit of measurement is stored in the registry
entry = entity_registry.async_get(entity.entity_id)
assert entry.unit_of_measurement == suggested_unit
assert entry.options == {
"sensor.private": {"suggested_unit_of_measurement": suggested_unit},
assert entry.options["sensor.private"] == {
"suggested_unit_of_measurement": suggested_unit
}

66
tests/components/sensorpush_cloud/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfLength.METERS: 'm'>,
}),
@ -79,6 +82,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPressure.HPA: 'hPa'>,
}),
@ -135,6 +141,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -188,6 +197,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -214,7 +226,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_0_humidity-entry]
@ -347,6 +359,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -373,7 +388,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_0_vapor_pressure-entry]
@ -400,6 +415,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -453,6 +471,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfLength.METERS: 'm'>,
}),
@ -509,6 +530,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPressure.HPA: 'hPa'>,
}),
@ -565,6 +589,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -618,6 +645,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -644,7 +674,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_1_humidity-entry]
@ -777,6 +807,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -803,7 +836,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_1_vapor_pressure-entry]
@ -830,6 +863,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,
@ -883,6 +919,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfLength.METERS: 'm'>,
}),
@ -939,6 +978,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPressure.HPA: 'hPa'>,
}),
@ -995,6 +1037,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1048,6 +1093,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1074,7 +1122,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_2_humidity-entry]
@ -1207,6 +1255,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1233,7 +1284,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17.8',
'state': '-17.7777777777778',
})
# ---
# name: test_sensors[sensor.test_sensor_name_2_vapor_pressure-entry]
@ -1260,6 +1311,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.PRESSURE: 'pressure'>,
'original_icon': None,

6
tests/components/sfr_box/snapshots/test_sensor.ambr
View File

@ -449,6 +449,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,
@ -484,6 +487,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_RATE: 'data_rate'>,
'original_icon': None,

267
tests/components/sma/snapshots/test_sensor.ambr
View File

@ -219,6 +219,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -272,6 +275,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -325,6 +331,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -378,6 +387,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -431,6 +443,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -484,6 +499,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -537,6 +555,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -590,6 +611,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -643,6 +667,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -696,6 +723,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -749,6 +779,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -802,6 +835,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -855,6 +891,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -908,6 +947,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -961,6 +1003,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1014,6 +1059,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1067,6 +1115,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1120,6 +1171,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1173,6 +1227,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1226,6 +1283,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1279,6 +1339,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1332,6 +1395,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1645,6 +1711,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1698,6 +1767,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1751,6 +1823,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1804,6 +1879,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1857,6 +1935,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1910,6 +1991,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1963,6 +2047,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2016,6 +2103,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2069,6 +2159,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2122,6 +2215,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -2175,6 +2271,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -2228,6 +2327,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -2281,6 +2383,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -2334,6 +2439,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -2387,6 +2495,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -2440,6 +2551,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.APPARENT_POWER: 'apparent_power'>,
'original_icon': None,
@ -2541,6 +2655,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -2694,6 +2811,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.REACTIVE_POWER: 'reactive_power'>,
'original_icon': None,
@ -2747,6 +2867,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.REACTIVE_POWER: 'reactive_power'>,
'original_icon': None,
@ -2800,6 +2923,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.REACTIVE_POWER: 'reactive_power'>,
'original_icon': None,
@ -2853,6 +2979,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.REACTIVE_POWER: 'reactive_power'>,
'original_icon': None,
@ -2954,6 +3083,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -3055,6 +3187,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3156,6 +3291,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3209,6 +3347,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3262,6 +3403,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3315,6 +3459,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3368,6 +3515,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3421,6 +3571,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3474,6 +3627,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3527,6 +3683,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -3580,6 +3739,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -3633,6 +3795,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -3686,6 +3851,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.FREQUENCY: 'frequency'>,
'original_icon': None,
@ -3739,6 +3907,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3792,6 +3963,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -3845,6 +4019,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -3898,6 +4075,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -3951,6 +4131,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -4004,6 +4187,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -4057,6 +4243,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -4110,6 +4299,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -4259,6 +4451,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -4312,6 +4507,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4365,6 +4563,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4418,6 +4619,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -4471,6 +4675,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4524,6 +4731,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4577,6 +4787,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4630,6 +4843,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -4683,6 +4899,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -4736,6 +4955,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -4789,6 +5011,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -4894,6 +5119,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -4947,6 +5175,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -5000,6 +5231,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -5053,6 +5287,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -5106,6 +5343,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5159,6 +5399,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5212,6 +5455,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5265,6 +5511,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -5318,6 +5567,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -5371,6 +5623,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5472,6 +5727,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -5525,6 +5783,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5578,6 +5839,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -5631,6 +5895,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,

150
tests/components/smartthings/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -181,6 +187,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -234,6 +243,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -287,6 +299,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -390,6 +405,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -555,6 +573,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -658,6 +679,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1076,6 +1100,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1746,6 +1773,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2183,6 +2213,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2620,6 +2653,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -2880,6 +2916,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3724,6 +3763,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3776,6 +3818,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -3802,7 +3847,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-17',
'state': '-17.2222222222222',
})
# ---
# name: test_all_entities[da_ks_oven_01061][sensor.oven_completion_time-entry]
@ -4128,6 +4173,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4180,6 +4228,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4590,6 +4641,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4615,7 +4669,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '218',
'state': '218.333333333333',
})
# ---
# name: test_all_entities[da_ks_range_0101x][sensor.vulcan_temperature-entry]
@ -4642,6 +4696,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4668,7 +4725,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '218',
'state': '218.333333333333',
})
# ---
# name: test_all_entities[da_ref_normal_000001][sensor.refrigerator_energy-entry]
@ -4863,6 +4920,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4889,7 +4949,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-18',
'state': '-17.7777777777778',
})
# ---
# name: test_all_entities[da_ref_normal_000001][sensor.refrigerator_fridge_temperature-entry]
@ -4916,6 +4976,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -4942,7 +5005,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '3',
'state': '2.77777777777778',
})
# ---
# name: test_all_entities[da_ref_normal_000001][sensor.refrigerator_power-entry]
@ -5251,6 +5314,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5277,7 +5343,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '-18',
'state': '-17.7777777777778',
})
# ---
# name: test_all_entities[da_ref_normal_01001][sensor.refrigerator_fridge_temperature-entry]
@ -5304,6 +5370,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5330,7 +5399,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '3',
'state': '2.77777777777778',
})
# ---
# name: test_all_entities[da_ref_normal_01001][sensor.refrigerator_power-entry]
@ -5639,6 +5708,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -5692,6 +5764,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -10452,6 +10527,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,
@ -10700,6 +10778,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -10726,7 +10807,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '22',
'state': '21.6666666666667',
})
# ---
# name: test_all_entities[ecobee_thermostat][sensor.main_floor_humidity-entry]
@ -10806,6 +10887,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -10832,7 +10916,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '22',
'state': '21.6666666666667',
})
# ---
# name: test_all_entities[ecobee_thermostat_offline][sensor.downstairs_humidity-entry]
@ -10964,6 +11048,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfVolume.CUBIC_METERS: 'm³'>,
}),
@ -10993,7 +11080,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '40',
'state': '39.6435852288',
})
# ---
# name: test_all_entities[gas_meter][sensor.gas_meter_gas_meter-entry]
@ -11020,6 +11107,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -11274,6 +11364,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11377,6 +11470,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -11430,6 +11526,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -11483,6 +11582,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11586,6 +11688,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfPressure.HPA: 'hPa'>,
}),
@ -11615,7 +11720,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1000',
'state': '1000.0',
})
# ---
# name: test_all_entities[lumi][sensor.outdoor_temp_battery-entry]
@ -11745,6 +11850,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11771,7 +11879,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '24.4',
'state': '24.4444444444444',
})
# ---
# name: test_all_entities[multipurpose_sensor][sensor.deck_door_battery-entry]
@ -11848,6 +11956,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -11874,7 +11985,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '19.4',
'state': '19.4444444444444',
})
# ---
# name: test_all_entities[multipurpose_sensor][sensor.deck_door_x_coordinate-entry]
@ -12098,6 +12209,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -12124,7 +12238,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '23.6',
'state': '23.6111111111111',
})
# ---
# name: test_all_entities[sensibo_airconditioner_1][sensor.office_air_conditioner_mode-entry]
@ -12197,6 +12311,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -12559,6 +12676,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -12585,7 +12705,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '4734.552604985020',
'state': '4734.55260498502',
})
# ---
# name: test_all_entities[virtual_water_sensor][sensor.asd_battery-entry]

9
tests/components/smarty/snapshots/test_sensor.ambr
View File

@ -21,6 +21,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -169,6 +172,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -219,6 +225,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

6
tests/components/smlight/snapshots/test_sensor.ambr
View File

@ -186,6 +186,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,
@ -294,6 +297,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.DATA_SIZE: 'data_size'>,
'original_icon': None,

38
tests/components/solarlog/snapshots/test_sensor.ambr
View File

@ -82,6 +82,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -194,6 +197,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -247,6 +253,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -356,6 +365,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -757,6 +769,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -859,6 +874,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -912,6 +930,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -965,6 +986,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1018,6 +1042,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1127,6 +1154,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1180,6 +1210,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1410,6 +1443,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
}),
@ -1439,7 +1475,7 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '1.0230',
'state': '1.023',
})
# ---
# name: test_all_entities[sensor.solarlog_yield_yesterday-entry]

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

@ -16,7 +16,7 @@ async def test_steam_active(hass: HomeAssistant) -> None:
"""Test that the sensors are setup with the expected values when steam is active."""
await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_ACTIVE)
state = hass.states.get("sensor.steam_temperature")
assert state.state == "39"
assert round(float(state.state)) == 39
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
state = hass.states.get("sensor.steam_minutes_remain")
assert state.state == "14"
@ -27,7 +27,7 @@ async def test_steam_inactive(hass: HomeAssistant) -> None:
"""Test that the sensors are setup with the expected values when steam is not active."""
await _async_setup_entry_with_status(hass, MOCK_ASYNC_GET_STATUS_INACTIVE)
state = hass.states.get("sensor.steam_temperature")
assert state.state == "21"
assert round(float(state.state)) == 21
assert state.attributes[ATTR_UNIT_OF_MEASUREMENT] == UnitOfTemperature.CELSIUS
state = hass.states.get("sensor.steam_minutes_remain")
assert state.state == "0"

12
tests/components/subaru/api_responses.py
View File

@ -153,21 +153,21 @@ EXPECTED_STATE_EV_IMPERIAL = {
EXPECTED_STATE_EV_METRIC = {
"AVG_FUEL_CONSUMPTION": "4.6",
"DISTANCE_TO_EMPTY_FUEL": "274",
"DISTANCE_TO_EMPTY_FUEL": "273.59",
"EV_CHARGER_STATE_TYPE": "CHARGING",
"EV_CHARGE_SETTING_AMPERE_TYPE": "MAXIMUM",
"EV_CHARGE_VOLT_TYPE": "CHARGE_LEVEL_1",
"EV_DISTANCE_TO_EMPTY": "2",
"EV_DISTANCE_TO_EMPTY": "1.61",
"EV_IS_PLUGGED_IN": "UNLOCKED_CONNECTED",
"EV_STATE_OF_CHARGE_MODE": "EV_MODE",
"EV_STATE_OF_CHARGE_PERCENT": "20",
"EV_TIME_TO_FULLY_CHARGED_UTC": "2020-07-24T03:06:40+00:00",
"ODOMETER": "1986",
"ODOMETER": "1985.93",
"TIMESTAMP": 1595560000.0,
"TRANSMISSION_MODE": "UNKNOWN",
"TYRE_PRESSURE_FRONT_LEFT": "0.0",
"TYRE_PRESSURE_FRONT_RIGHT": "219.9",
"TYRE_PRESSURE_REAR_LEFT": "224.8",
"TYRE_PRESSURE_FRONT_LEFT": "0.00",
"TYRE_PRESSURE_FRONT_RIGHT": "219.94",
"TYRE_PRESSURE_REAR_LEFT": "224.77",
"TYRE_PRESSURE_REAR_RIGHT": "unknown",
"VEHICLE_STATE_TYPE": "IGNITION_OFF",
"LATITUDE": 40.0,

6
tests/components/subaru/test_sensor.py
View File

@ -27,6 +27,8 @@ from .conftest import (
setup_subaru_config_entry,
)
from tests.common import get_sensor_display_state
async def test_sensors_ev_metric(hass: HomeAssistant, ev_entry) -> None:
"""Test sensors supporting metric units."""
@ -141,5 +143,5 @@ def _assert_data(hass: HomeAssistant, expected_state: dict[str, Any]) -> None:
expected_states[entity] = expected_state[item.key]
for sensor, value in expected_states.items():
actual = hass.states.get(sensor)
assert actual.state == value
state = get_sensor_display_state(hass, entity_registry, sensor)
assert state == value

3
tests/components/suez_water/snapshots/test_sensor.ambr
View File

@ -72,6 +72,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.WATER: 'water'>,
'original_icon': None,

8
tests/components/swiss_public_transport/snapshots/test_sensor.ambr
View File

@ -21,6 +21,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.DURATION: 'duration'>,
'original_icon': None,
@ -369,6 +372,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
'sensor.private': dict({
'suggested_unit_of_measurement': <UnitOfTime.HOURS: 'h'>,
}),
@ -398,6 +404,6 @@
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.003',
'state': '0.00277777777777778',
})
# ---

6
tests/components/swiss_public_transport/test_sensor.py
View File

@ -83,7 +83,10 @@ async def test_fetching_data(
hass.states.get("sensor.zurich_bern_departure_2").state
== "2024-01-06T17:05:00+00:00"
)
assert hass.states.get("sensor.zurich_bern_trip_duration").state == "0.003"
assert (
round(float(hass.states.get("sensor.zurich_bern_trip_duration").state), 3)
== 0.003
)
assert hass.states.get("sensor.zurich_bern_platform").state == "0"
assert hass.states.get("sensor.zurich_bern_transfers").state == "0"
assert hass.states.get("sensor.zurich_bern_delay").state == "0"
@ -139,7 +142,6 @@ async def test_fetching_data_setup_exception(
"""Test fetching data with setup exception."""
mock_opendata_client.async_get_data.side_effect = raise_error
await setup_integration(hass, swiss_public_transport_config_entry)
assert swiss_public_transport_config_entry.state is state

6
tests/components/switchbot_cloud/snapshots/test_sensor.ambr
View File

@ -129,6 +129,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -288,6 +291,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,

51
tests/components/tasmota/snapshots/test_sensor.ambr
View File

@ -39,6 +39,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -275,6 +278,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -424,6 +430,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -477,6 +486,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -530,6 +542,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -615,6 +630,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -774,6 +792,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -859,6 +880,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -912,6 +936,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1029,6 +1056,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1082,6 +1112,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1199,6 +1232,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1284,6 +1320,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 1,
}),
}),
'original_device_class': <SensorDeviceClass.TEMPERATURE: 'temperature'>,
'original_icon': None,
@ -1454,6 +1493,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -1603,6 +1645,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.POWER: 'power'>,
'original_icon': None,
@ -1656,6 +1701,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -1709,6 +1757,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,

18
tests/components/technove/snapshots/test_sensor.ambr
View File

@ -23,6 +23,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -76,6 +79,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -129,6 +135,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,
@ -182,6 +191,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.CURRENT: 'current'>,
'original_icon': None,
@ -235,6 +247,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.VOLTAGE: 'voltage'>,
'original_icon': None,
@ -405,6 +420,9 @@
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 2,
}),
}),
'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
'original_icon': None,

Some files were not shown because too many files have changed in this diff Show More