Use snapshot testing in GIOS sensor (#115876)

Co-authored-by: Maciej Bieniek <478555+bieniu@users.noreply.github.com>
This commit is contained in:
Maciej Bieniek 2024-04-20 12:32:11 +02:00 committed by GitHub
parent c8d52c02c5
commit c2450c1112
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 789 additions and 230 deletions

View File

@ -0,0 +1,774 @@
# serializer version: 1
# name: test_sensor[sensor.home_air_quality_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_air_quality_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'Air quality index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'aqi',
'unique_id': '123-aqi',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_air_quality_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home Air quality index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_air_quality_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'good',
})
# ---
# name: test_sensor[sensor.home_benzene-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_benzene',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Benzene',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'c6h6',
'unique_id': '123-c6h6',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_benzene-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'friendly_name': 'Home Benzene',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_benzene',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '0.23789',
})
# ---
# name: test_sensor[sensor.home_carbon_monoxide-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_carbon_monoxide',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': None,
'original_icon': None,
'original_name': 'Carbon monoxide',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'co',
'unique_id': '123-co',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_carbon_monoxide-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'friendly_name': 'Home Carbon monoxide',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_carbon_monoxide',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '251.874',
})
# ---
# name: test_sensor[sensor.home_nitrogen_dioxide-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_nitrogen_dioxide',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.NITROGEN_DIOXIDE: 'nitrogen_dioxide'>,
'original_icon': None,
'original_name': 'Nitrogen dioxide',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '123-no2',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_nitrogen_dioxide-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'nitrogen_dioxide',
'friendly_name': 'Home Nitrogen dioxide',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_nitrogen_dioxide',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '7.13411',
})
# ---
# name: test_sensor[sensor.home_nitrogen_dioxide_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_nitrogen_dioxide_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'Nitrogen dioxide index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'no2_index',
'unique_id': '123-no2-index',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_nitrogen_dioxide_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home Nitrogen dioxide index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_nitrogen_dioxide_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'good',
})
# ---
# name: test_sensor[sensor.home_ozone-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_ozone',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.OZONE: 'ozone'>,
'original_icon': None,
'original_name': 'Ozone',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '123-o3',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_ozone-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'ozone',
'friendly_name': 'Home Ozone',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_ozone',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '95.7768',
})
# ---
# name: test_sensor[sensor.home_ozone_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_ozone_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'Ozone index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'o3_index',
'unique_id': '123-o3-index',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_ozone_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home Ozone index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_ozone_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'good',
})
# ---
# name: test_sensor[sensor.home_pm10-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_pm10',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PM10: 'pm10'>,
'original_icon': None,
'original_name': 'PM10',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '123-pm10',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_pm10-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'pm10',
'friendly_name': 'Home PM10',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_pm10',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '16.8344',
})
# ---
# name: test_sensor[sensor.home_pm10_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_pm10_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'PM10 index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'pm10_index',
'unique_id': '123-pm10-index',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_pm10_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home PM10 index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_pm10_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'good',
})
# ---
# name: test_sensor[sensor.home_pm2_5-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_pm2_5',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.PM25: 'pm25'>,
'original_icon': None,
'original_name': 'PM2.5',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '123-pm25',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_pm2_5-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'pm25',
'friendly_name': 'Home PM2.5',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_pm2_5',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '4',
})
# ---
# name: test_sensor[sensor.home_pm2_5_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_pm2_5_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'PM2.5 index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'pm25_index',
'unique_id': '123-pm25-index',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_pm2_5_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home PM2.5 index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_pm2_5_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'good',
})
# ---
# name: test_sensor[sensor.home_sulphur_dioxide-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_sulphur_dioxide',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
'sensor': dict({
'suggested_display_precision': 0,
}),
}),
'original_device_class': <SensorDeviceClass.SULPHUR_DIOXIDE: 'sulphur_dioxide'>,
'original_icon': None,
'original_name': 'Sulphur dioxide',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': None,
'unique_id': '123-so2',
'unit_of_measurement': 'µg/m³',
})
# ---
# name: test_sensor[sensor.home_sulphur_dioxide-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'sulphur_dioxide',
'friendly_name': 'Home Sulphur dioxide',
'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
'unit_of_measurement': 'µg/m³',
}),
'context': <ANY>,
'entity_id': 'sensor.home_sulphur_dioxide',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': '4.35478',
})
# ---
# name: test_sensor[sensor.home_sulphur_dioxide_index-entry]
EntityRegistryEntrySnapshot({
'aliases': set({
}),
'area_id': None,
'capabilities': dict({
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'config_entry_id': <ANY>,
'device_class': None,
'device_id': <ANY>,
'disabled_by': None,
'domain': 'sensor',
'entity_category': None,
'entity_id': 'sensor.home_sulphur_dioxide_index',
'has_entity_name': True,
'hidden_by': None,
'icon': None,
'id': <ANY>,
'labels': set({
}),
'name': None,
'options': dict({
}),
'original_device_class': <SensorDeviceClass.ENUM: 'enum'>,
'original_icon': None,
'original_name': 'Sulphur dioxide index',
'platform': 'gios',
'previous_unique_id': None,
'supported_features': 0,
'translation_key': 'so2_index',
'unique_id': '123-so2-index',
'unit_of_measurement': None,
})
# ---
# name: test_sensor[sensor.home_sulphur_dioxide_index-state]
StateSnapshot({
'attributes': ReadOnlyDict({
'attribution': 'Data provided by GIOŚ',
'device_class': 'enum',
'friendly_name': 'Home Sulphur dioxide index',
'options': list([
'very_bad',
'bad',
'sufficient',
'moderate',
'good',
'very_good',
]),
}),
'context': <ANY>,
'entity_id': 'sensor.home_sulphur_dioxide_index',
'last_changed': <ANY>,
'last_reported': <ANY>,
'last_updated': <ANY>,
'state': 'very_good',
})
# ---

View File

@ -6,23 +6,11 @@ import json
from unittest.mock import patch
from gios import ApiError
from syrupy import SnapshotAssertion
from homeassistant.components.gios.const import ATTRIBUTION, DOMAIN
from homeassistant.components.sensor import (
ATTR_OPTIONS,
ATTR_STATE_CLASS,
DOMAIN as PLATFORM,
SensorDeviceClass,
SensorStateClass,
)
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_DEVICE_CLASS,
ATTR_ICON,
ATTR_UNIT_OF_MEASUREMENT,
CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
STATE_UNAVAILABLE,
)
from homeassistant.components.gios.const import DOMAIN
from homeassistant.components.sensor import DOMAIN as PLATFORM
from homeassistant.const import STATE_UNAVAILABLE, Platform
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_registry as er
from homeassistant.util.dt import utcnow
@ -32,223 +20,20 @@ from . import init_integration
from tests.common import async_fire_time_changed, load_fixture
async def test_sensor(hass: HomeAssistant, entity_registry: er.EntityRegistry) -> None:
async def test_sensor(
hass: HomeAssistant, entity_registry: er.EntityRegistry, snapshot: SnapshotAssertion
) -> None:
"""Test states of the sensor."""
await init_integration(hass)
with patch("homeassistant.components.gios.PLATFORMS", [Platform.SENSOR]):
entry = await init_integration(hass)
state = hass.states.get("sensor.home_benzene")
assert state
assert state.state == "0.23789"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
assert state.attributes.get(ATTR_ICON) is None
entity_entries = er.async_entries_for_config_entry(entity_registry, entry.entry_id)
entry = entity_registry.async_get("sensor.home_benzene")
assert entry
assert entry.unique_id == "123-c6h6"
state = hass.states.get("sensor.home_carbon_monoxide")
assert state
assert state.state == "251.874"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) is None
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_carbon_monoxide")
assert entry
assert entry.unique_id == "123-co"
state = hass.states.get("sensor.home_nitrogen_dioxide")
assert state
assert state.state == "7.13411"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.NITROGEN_DIOXIDE
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_nitrogen_dioxide")
assert entry
assert entry.unique_id == "123-no2"
state = hass.states.get("sensor.home_nitrogen_dioxide_index")
assert state
assert state.state == "good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_nitrogen_dioxide_index")
assert entry
assert entry.unique_id == "123-no2-index"
state = hass.states.get("sensor.home_ozone")
assert state
assert state.state == "95.7768"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.OZONE
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_ozone")
assert entry
assert entry.unique_id == "123-o3"
state = hass.states.get("sensor.home_ozone_index")
assert state
assert state.state == "good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_ozone_index")
assert entry
assert entry.unique_id == "123-o3-index"
state = hass.states.get("sensor.home_pm10")
assert state
assert state.state == "16.8344"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM10
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_pm10")
assert entry
assert entry.unique_id == "123-pm10"
state = hass.states.get("sensor.home_pm10_index")
assert state
assert state.state == "good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_pm10_index")
assert entry
assert entry.unique_id == "123-pm10-index"
state = hass.states.get("sensor.home_pm2_5")
assert state
assert state.state == "4"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM25
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_pm2_5")
assert entry
assert entry.unique_id == "123-pm25"
state = hass.states.get("sensor.home_pm2_5_index")
assert state
assert state.state == "good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_pm2_5_index")
assert entry
assert entry.unique_id == "123-pm25-index"
state = hass.states.get("sensor.home_sulphur_dioxide")
assert state
assert state.state == "4.35478"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.SULPHUR_DIOXIDE
assert state.attributes.get(ATTR_STATE_CLASS) == SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.home_sulphur_dioxide")
assert entry
assert entry.unique_id == "123-so2"
state = hass.states.get("sensor.home_sulphur_dioxide_index")
assert state
assert state.state == "very_good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_sulphur_dioxide_index")
assert entry
assert entry.unique_id == "123-so2-index"
state = hass.states.get("sensor.home_air_quality_index")
assert state
assert state.state == "good"
assert state.attributes.get(ATTR_ATTRIBUTION) == ATTRIBUTION
assert state.attributes.get(ATTR_STATE_CLASS) is None
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) is None
assert state.attributes.get(ATTR_OPTIONS) == [
"very_bad",
"bad",
"sufficient",
"moderate",
"good",
"very_good",
]
entry = entity_registry.async_get("sensor.home_air_quality_index")
assert entry
assert entry.unique_id == "123-aqi"
assert entity_entries
for entity_entry in entity_entries:
assert entity_entry == snapshot(name=f"{entity_entry.entity_id}-entry")
assert (state := hass.states.get(entity_entry.entity_id))
assert state == snapshot(name=f"{entity_entry.entity_id}-state")
async def test_availability(hass: HomeAssistant) -> None: