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

Use snapshot testing in NAM sensor and diagnostics (#115877)

Browse Source 
* Use snapshot testing in NAM diagnostics

* Use snapshot testing in NAM sensor

* Add NAM data fixture

---------

Co-authored-by: Maciej Bieniek <478555+bieniu@users.noreply.github.com>
This commit is contained in:
Maciej Bieniek 2024-04-20 12:34:27 +02:00 committed by GitHub
parent c4e7a7af21
commit 194f3366ce
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 1820 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
tests/components/nam/__init__.py
View File

@ -4,44 +4,13 @@ from unittest.mock import AsyncMock, Mock, patch
from homeassistant.components.nam.const import DOMAIN
from tests.common import MockConfigEntry
from tests.common import MockConfigEntry, load_json_object_fixture
INCOMPLETE_NAM_DATA = {
"software_version": "NAMF-2020-36",
"sensordatavalues": [],
}
nam_data = {
"software_version": "NAMF-2020-36",
"uptime": "456987",
"sensordatavalues": [
{"value_type": "PMS_P0", "value": "6.00"},
{"value_type": "PMS_P1", "value": "10.00"},
{"value_type": "PMS_P2", "value": "11.00"},
{"value_type": "SDS_P1", "value": "18.65"},
{"value_type": "SDS_P2", "value": "11.03"},
{"value_type": "SPS30_P0", "value": "31.23"},
{"value_type": "SPS30_P1", "value": "21.23"},
{"value_type": "SPS30_P2", "value": "34.32"},
{"value_type": "SPS30_P4", "value": "24.72"},
{"value_type": "conc_co2_ppm", "value": "865"},
{"value_type": "BME280_temperature", "value": "7.56"},
{"value_type": "BME280_humidity", "value": "45.69"},
{"value_type": "BME280_pressure", "value": "101101.17"},
{"value_type": "BMP_temperature", "value": "7.56"},
{"value_type": "BMP_pressure", "value": "103201.18"},
{"value_type": "BMP280_temperature", "value": "5.56"},
{"value_type": "BMP280_pressure", "value": "102201.18"},
{"value_type": "SHT3X_temperature", "value": "6.28"},
{"value_type": "SHT3X_humidity", "value": "34.69"},
{"value_type": "humidity", "value": "46.23"},
{"value_type": "temperature", "value": "6.26"},
{"value_type": "HECA_temperature", "value": "7.95"},
{"value_type": "HECA_humidity", "value": "49.97"},
{"value_type": "signal", "value": "-72"},
],
}
async def init_integration(hass, co2_sensor=True) -> MockConfigEntry:
"""Set up the Nettigo Air Monitor integration in Home Assistant."""
@ -52,6 +21,8 @@ async def init_integration(hass, co2_sensor=True) -> MockConfigEntry:
data={"host": "10.10.2.3"},
)
nam_data = load_json_object_fixture("nam/nam_data.json")
if not co2_sensor:
# Remove conc_co2_ppm value
nam_data["sensordatavalues"].pop(6)

33
tests/components/nam/fixtures/diagnostics_data.json
View File

@ -1,33 +0,0 @@
{
"bme280_humidity": 45.7,
"bme280_pressure": 1011.012,
"bme280_temperature": 7.6,
"bmp180_pressure": 1032.012,
"bmp180_temperature": 7.6,
"bmp280_pressure": 1022.012,
"bmp280_temperature": 5.6,
"dht22_humidity": 46.2,
"dht22_temperature": 6.3,
"heca_humidity": 50.0,
"heca_temperature": 8.0,
"mhz14a_carbon_dioxide": 865.0,
"pms_caqi": 19,
"pms_caqi_level": "very_low",
"pms_p0": 6.0,
"pms_p1": 10.0,
"pms_p2": 11.0,
"sds011_caqi": 19,
"sds011_caqi_level": "very_low",
"sds011_p1": 18.6,
"sds011_p2": 11.0,
"sht3x_humidity": 34.7,
"sht3x_temperature": 6.3,
"signal": -72.0,
"sps30_caqi": 54,
"sps30_caqi_level": "medium",
"sps30_p0": 31.2,
"sps30_p1": 21.2,
"sps30_p2": 34.3,
"sps30_p4": 24.7,
"uptime": 456987
}

30
tests/components/nam/fixtures/nam_data.json Normal file
View File

@ -0,0 +1,30 @@
{
"software_version": "NAMF-2020-36",
"uptime": "456987",
"sensordatavalues": [
{ "value_type": "PMS_P0", "value": "6.00" },
{ "value_type": "PMS_P1", "value": "10.00" },
{ "value_type": "PMS_P2", "value": "11.00" },
{ "value_type": "SDS_P1", "value": "18.65" },
{ "value_type": "SDS_P2", "value": "11.03" },
{ "value_type": "SPS30_P0", "value": "31.23" },
{ "value_type": "SPS30_P1", "value": "21.23" },
{ "value_type": "SPS30_P2", "value": "34.32" },
{ "value_type": "SPS30_P4", "value": "24.72" },
{ "value_type": "conc_co2_ppm", "value": "865" },
{ "value_type": "BME280_temperature", "value": "7.56" },
{ "value_type": "BME280_humidity", "value": "45.69" },
{ "value_type": "BME280_pressure", "value": "101101.17" },
{ "value_type": "BMP_temperature", "value": "7.56" },
{ "value_type": "BMP_pressure", "value": "103201.18" },
{ "value_type": "BMP280_temperature", "value": "5.56" },
{ "value_type": "BMP280_pressure", "value": "102201.18" },
{ "value_type": "SHT3X_temperature", "value": "6.28" },
{ "value_type": "SHT3X_humidity", "value": "34.69" },
{ "value_type": "humidity", "value": "46.23" },
{ "value_type": "temperature", "value": "6.26" },
{ "value_type": "HECA_temperature", "value": "7.95" },
{ "value_type": "HECA_humidity", "value": "49.97" },
{ "value_type": "signal", "value": "-72" }
]
}

41
tests/components/nam/snapshots/test_diagnostics.ambr Normal file
View File

@ -0,0 +1,41 @@
# serializer version: 1
# name: test_entry_diagnostics
dict({
'data': dict({
'bme280_humidity': 45.7,
'bme280_pressure': 1011.012,
'bme280_temperature': 7.6,
'bmp180_pressure': 1032.012,
'bmp180_temperature': 7.6,
'bmp280_pressure': 1022.012,
'bmp280_temperature': 5.6,
'dht22_humidity': 46.2,
'dht22_temperature': 6.3,
'heca_humidity': 50.0,
'heca_temperature': 8.0,
'mhz14a_carbon_dioxide': 865.0,
'pms_caqi': 19,
'pms_caqi_level': 'very_low',
'pms_p0': 6.0,
'pms_p1': 10.0,
'pms_p2': 11.0,
'sds011_caqi': 19,
'sds011_caqi_level': 'very_low',
'sds011_p1': 18.6,
'sds011_p2': 11.0,
'sht3x_humidity': 34.7,
'sht3x_temperature': 6.3,
'signal': -72.0,
'sps30_caqi': 54,
'sps30_caqi_level': 'medium',
'sps30_p0': 31.2,
'sps30_p1': 21.2,
'sps30_p2': 34.3,
'sps30_p4': 24.7,
'uptime': 456987,
}),
'info': dict({
'host': '10.10.2.3',
}),
})
# ---

1714
tests/components/nam/snapshots/test_sensor.ambr Normal file
View File

File diff suppressed because it is too large Load Diff

12
tests/components/nam/test_diagnostics.py
View File

@ -1,25 +1,23 @@
"""Test NAM diagnostics."""
import json
from syrupy import SnapshotAssertion
from homeassistant.core import HomeAssistant
from . import init_integration
from tests.common import load_fixture
from tests.components.diagnostics import get_diagnostics_for_config_entry
from tests.typing import ClientSessionGenerator
async def test_entry_diagnostics(
hass: HomeAssistant, hass_client: ClientSessionGenerator
hass: HomeAssistant,
hass_client: ClientSessionGenerator,
snapshot: SnapshotAssertion,
) -> None:
"""Test config entry diagnostics."""
entry = await init_integration(hass)
diagnostics_data = json.loads(load_fixture("diagnostics_data.json", "nam"))
result = await get_diagnostics_for_config_entry(hass, hass_client, entry)
assert result["info"] == {"host": "10.10.2.3"}
assert result["data"] == diagnostics_data
assert result == snapshot

474
tests/components/nam/test_sensor.py
View File

@ -3,27 +3,18 @@
from datetime import timedelta
from unittest.mock import AsyncMock, Mock, patch
from freezegun.api import FrozenDateTimeFactory
from nettigo_air_monitor import ApiError
from syrupy import SnapshotAssertion
from homeassistant.components.nam.const import DOMAIN
from homeassistant.components.sensor import (
ATTR_OPTIONS,
ATTR_STATE_CLASS,
DOMAIN as SENSOR_DOMAIN,
SensorDeviceClass,
SensorStateClass,
)
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN, SensorDeviceClass
from homeassistant.const import (
ATTR_DEVICE_CLASS,
ATTR_ENTITY_ID,
ATTR_ICON,
ATTR_UNIT_OF_MEASUREMENT,
CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
CONCENTRATION_PARTS_PER_MILLION,
PERCENTAGE,
SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
STATE_UNAVAILABLE,
UnitOfPressure,
Platform,
UnitOfTemperature,
)
from homeassistant.core import HomeAssistant
@ -31,447 +22,32 @@ from homeassistant.helpers import entity_registry as er
from homeassistant.setup import async_setup_component
from homeassistant.util.dt import utcnow
from . import INCOMPLETE_NAM_DATA, init_integration, nam_data
from . import INCOMPLETE_NAM_DATA, init_integration
from tests.common import async_fire_time_changed
from tests.common import async_fire_time_changed, load_json_object_fixture
async def test_sensor(hass: HomeAssistant, entity_registry: er.EntityRegistry) -> None:
async def test_sensor(
hass: HomeAssistant,
entity_registry_enabled_by_default: None,
entity_registry: er.EntityRegistry,
snapshot: SnapshotAssertion,
freezer: FrozenDateTimeFactory,
) -> None:
"""Test states of the air_quality."""
entity_registry.async_get_or_create(
SENSOR_DOMAIN,
DOMAIN,
"aa:bb:cc:dd:ee:ff-signal",
suggested_object_id="nettigo_air_monitor_signal_strength",
disabled_by=None,
)
hass.config.set_time_zone("UTC")
freezer.move_to("2024-04-20 12:00:00+00:00")
entity_registry.async_get_or_create(
SENSOR_DOMAIN,
DOMAIN,
"aa:bb:cc:dd:ee:ff-uptime",
suggested_object_id="nettigo_air_monitor_uptime",
disabled_by=None,
)
with patch("homeassistant.components.nam.PLATFORMS", [Platform.SENSOR]):
entry = await init_integration(hass)
# Patch return value from utcnow, with offset to make sure the patch is correct
now = utcnow() - timedelta(hours=1)
with patch("homeassistant.components.nam.sensor.utcnow", return_value=now):
await init_integration(hass)
entity_entries = er.async_entries_for_config_entry(entity_registry, entry.entry_id)
state = hass.states.get("sensor.nettigo_air_monitor_bme280_humidity")
assert state
assert state.state == "45.7"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.HUMIDITY
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == PERCENTAGE
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bme280_humidity")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bme280_humidity"
state = hass.states.get("sensor.nettigo_air_monitor_bme280_temperature")
assert state
assert state.state == "7.6"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bme280_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bme280_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_bme280_pressure")
assert state
assert state.state == "1011.012"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PRESSURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfPressure.HPA
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bme280_pressure")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bme280_pressure"
state = hass.states.get("sensor.nettigo_air_monitor_bmp180_temperature")
assert state
assert state.state == "7.6"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bmp180_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bmp180_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_bmp180_pressure")
assert state
assert state.state == "1032.012"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PRESSURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfPressure.HPA
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bmp180_pressure")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bmp180_pressure"
state = hass.states.get("sensor.nettigo_air_monitor_bmp280_temperature")
assert state
assert state.state == "5.6"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bmp280_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bmp280_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_bmp280_pressure")
assert state
assert state.state == "1022.012"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PRESSURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfPressure.HPA
entry = entity_registry.async_get("sensor.nettigo_air_monitor_bmp280_pressure")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-bmp280_pressure"
state = hass.states.get("sensor.nettigo_air_monitor_sht3x_humidity")
assert state
assert state.state == "34.7"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.HUMIDITY
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == PERCENTAGE
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sht3x_humidity")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sht3x_humidity"
state = hass.states.get("sensor.nettigo_air_monitor_sht3x_temperature")
assert state
assert state.state == "6.3"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sht3x_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sht3x_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_dht22_humidity")
assert state
assert state.state == "46.2"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.HUMIDITY
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == PERCENTAGE
entry = entity_registry.async_get("sensor.nettigo_air_monitor_dht22_humidity")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-dht22_humidity"
state = hass.states.get("sensor.nettigo_air_monitor_dht22_temperature")
assert state
assert state.state == "6.3"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_dht22_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-dht22_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_heca_humidity")
assert state
assert state.state == "50.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.HUMIDITY
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == PERCENTAGE
entry = entity_registry.async_get("sensor.nettigo_air_monitor_heca_humidity")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-heca_humidity"
state = hass.states.get("sensor.nettigo_air_monitor_heca_temperature")
assert state
assert state.state == "8.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TEMPERATURE
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert state.attributes.get(ATTR_UNIT_OF_MEASUREMENT) == UnitOfTemperature.CELSIUS
entry = entity_registry.async_get("sensor.nettigo_air_monitor_heca_temperature")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-heca_temperature"
state = hass.states.get("sensor.nettigo_air_monitor_signal_strength")
assert state
assert state.state == "-72.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.SIGNAL_STRENGTH
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== SIGNAL_STRENGTH_DECIBELS_MILLIWATT
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_signal_strength")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-signal"
state = hass.states.get("sensor.nettigo_air_monitor_uptime")
assert state
assert (
state.state
== (now - timedelta(seconds=456987)).replace(microsecond=0).isoformat()
)
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.TIMESTAMP
assert state.attributes.get(ATTR_STATE_CLASS) is None
entry = entity_registry.async_get("sensor.nettigo_air_monitor_uptime")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-uptime"
state = hass.states.get(
"sensor.nettigo_air_monitor_pmsx003_common_air_quality_index_level"
)
assert state
assert state.state == "very_low"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.ENUM
assert state.attributes.get(ATTR_OPTIONS) == [
"very_low",
"low",
"medium",
"high",
"very_high",
]
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_pmsx003_common_air_quality_index_level"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-pms_caqi_level"
assert entry.translation_key == "pmsx003_caqi_level"
state = hass.states.get(
"sensor.nettigo_air_monitor_pmsx003_common_air_quality_index"
)
assert state
assert state.state == "19"
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_pmsx003_common_air_quality_index"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-pms_caqi"
state = hass.states.get("sensor.nettigo_air_monitor_pmsx003_pm10")
assert state
assert state.state == "10.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM10
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_pmsx003_pm10")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-pms_p1"
state = hass.states.get("sensor.nettigo_air_monitor_pmsx003_pm2_5")
assert state
assert state.state == "11.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM25
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_pmsx003_pm2_5")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-pms_p2"
state = hass.states.get("sensor.nettigo_air_monitor_pmsx003_pm1")
assert state
assert state.state == "6.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM1
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_pmsx003_pm1")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-pms_p0"
state = hass.states.get("sensor.nettigo_air_monitor_sds011_pm10")
assert state
assert state.state == "18.6"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM10
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sds011_pm10")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sds011_p1"
state = hass.states.get(
"sensor.nettigo_air_monitor_sds011_common_air_quality_index"
)
assert state
assert state.state == "19"
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_sds011_common_air_quality_index"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sds011_caqi"
state = hass.states.get(
"sensor.nettigo_air_monitor_sds011_common_air_quality_index_level"
)
assert state
assert state.state == "very_low"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.ENUM
assert state.attributes.get(ATTR_OPTIONS) == [
"very_low",
"low",
"medium",
"high",
"very_high",
]
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_sds011_common_air_quality_index_level"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sds011_caqi_level"
assert entry.translation_key == "sds011_caqi_level"
state = hass.states.get("sensor.nettigo_air_monitor_sds011_pm2_5")
assert state
assert state.state == "11.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM25
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sds011_pm2_5")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sds011_p2"
state = hass.states.get("sensor.nettigo_air_monitor_sps30_common_air_quality_index")
assert state
assert state.state == "54"
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_sps30_common_air_quality_index"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_caqi"
state = hass.states.get(
"sensor.nettigo_air_monitor_sps30_common_air_quality_index_level"
)
assert state
assert state.state == "medium"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.ENUM
assert state.attributes.get(ATTR_OPTIONS) == [
"very_low",
"low",
"medium",
"high",
"very_high",
]
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_sps30_common_air_quality_index_level"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_caqi_level"
assert entry.translation_key == "sps30_caqi_level"
state = hass.states.get("sensor.nettigo_air_monitor_sps30_pm1")
assert state
assert state.state == "31.2"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM1
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sps30_pm1")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_p0"
state = hass.states.get("sensor.nettigo_air_monitor_sps30_pm10")
assert state
assert state.state == "21.2"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM10
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sps30_pm10")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_p1"
state = hass.states.get("sensor.nettigo_air_monitor_sps30_pm2_5")
assert state
assert state.state == "34.3"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.PM25
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sps30_pm2_5")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_p2"
state = hass.states.get("sensor.nettigo_air_monitor_sps30_pm4")
assert state
assert state.state == "24.7"
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_MICROGRAMS_PER_CUBIC_METER
)
assert state.attributes.get(ATTR_ICON) is None
entry = entity_registry.async_get("sensor.nettigo_air_monitor_sps30_pm4")
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-sps30_p4"
state = hass.states.get("sensor.nettigo_air_monitor_mh_z14a_carbon_dioxide")
assert state
assert state.state == "865.0"
assert state.attributes.get(ATTR_DEVICE_CLASS) == SensorDeviceClass.CO2
assert state.attributes.get(ATTR_STATE_CLASS) is SensorStateClass.MEASUREMENT
assert (
state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
== CONCENTRATION_PARTS_PER_MILLION
)
entry = entity_registry.async_get(
"sensor.nettigo_air_monitor_mh_z14a_carbon_dioxide"
)
assert entry
assert entry.unique_id == "aa:bb:cc:dd:ee:ff-mhz14a_carbon_dioxide"
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_sensor_disabled(
@ -524,6 +100,8 @@ async def test_incompleta_data_after_device_restart(hass: HomeAssistant) -> None
async def test_availability(hass: HomeAssistant) -> None:
"""Ensure that we mark the entities unavailable correctly when device causes an error."""
nam_data = load_json_object_fixture("nam/nam_data.json")
await init_integration(hass)
state = hass.states.get("sensor.nettigo_air_monitor_bme280_temperature")
@ -566,6 +144,8 @@ async def test_availability(hass: HomeAssistant) -> None:
async def test_manual_update_entity(hass: HomeAssistant) -> None:
"""Test manual update entity via service homeasasistant/update_entity."""
nam_data = load_json_object_fixture("nam/nam_data.json")
await init_integration(hass)
await async_setup_component(hass, "homeassistant", {})