Complete mysensors sensor coverage (#54471)

tests/components/mysensors/conftest.py

@@ -3,13 +3,14 @@ from __future__ import annotations
 
 from collections.abc import AsyncGenerator, Generator
 import json
-from typing import Any
+from typing import Any, Callable
 from unittest.mock import MagicMock, patch
 
 from mysensors.persistence import MySensorsJSONDecoder
 from mysensors.sensor import Sensor
 import pytest
 
+from homeassistant.components.device_tracker.legacy import Device
 from homeassistant.components.mqtt import DOMAIN as MQTT_DOMAIN
 from homeassistant.components.mysensors import CONF_VERSION, DEFAULT_BAUD_RATE
 from homeassistant.components.mysensors.const import (
@@ -27,14 +28,14 @@ from tests.common import MockConfigEntry, load_fixture
 
 
 @pytest.fixture(autouse=True)
-def device_tracker_storage(mock_device_tracker_conf):
+def device_tracker_storage(mock_device_tracker_conf: list[Device]) -> list[Device]:
     """Mock out device tracker known devices storage."""
     devices = mock_device_tracker_conf
     return devices
 
 
 @pytest.fixture(name="mqtt")
-def mock_mqtt_fixture(hass) -> None:
+def mock_mqtt_fixture(hass: HomeAssistant) -> None:
     """Mock the MQTT integration."""
     hass.config.components.add(MQTT_DOMAIN)
 
@@ -75,14 +76,14 @@ def mock_gateway_features(
 ) -> None:
     """Mock the gateway features."""
 
-    async def mock_start_persistence():
+    async def mock_start_persistence() -> None:
         """Load nodes from via persistence."""
         gateway = transport_class.call_args[0][0]
         gateway.sensors.update(nodes)
 
     tasks.start_persistence.side_effect = mock_start_persistence
 
-    async def mock_start():
+    async def mock_start() -> None:
         """Mock the start method."""
         gateway = transport_class.call_args[0][0]
         gateway.on_conn_made(gateway)
@@ -97,7 +98,7 @@ def transport_fixture(serial_transport: MagicMock) -> MagicMock:
 
 
 @pytest.fixture(name="serial_entry")
-async def serial_entry_fixture(hass) -> MockConfigEntry:
+async def serial_entry_fixture(hass: HomeAssistant) -> MockConfigEntry:
     """Create a config entry for a serial gateway."""
     entry = MockConfigEntry(
         domain=DOMAIN,
@@ -120,15 +121,25 @@ def config_entry_fixture(serial_entry: MockConfigEntry) -> MockConfigEntry:
 @pytest.fixture
 async def integration(
     hass: HomeAssistant, transport: MagicMock, config_entry: MockConfigEntry
-) -> AsyncGenerator[MockConfigEntry, None]:
+) -> AsyncGenerator[tuple[MockConfigEntry, Callable[[str], None]], None]:
     """Set up the mysensors integration with a config entry."""
     device = config_entry.data[CONF_DEVICE]
     config: dict[str, Any] = {DOMAIN: {CONF_GATEWAYS: [{CONF_DEVICE: device}]}}
     config_entry.add_to_hass(hass)
+
+    def receive_message(message_string: str) -> None:
+        """Receive a message with the transport.
+
+        The message_string parameter is a string in the MySensors message format.
+        """
+        gateway = transport.call_args[0][0]
+        # node_id;child_id;command;ack;type;payload\n
+        gateway.logic(message_string)
+
     with patch("homeassistant.components.mysensors.device.UPDATE_DELAY", new=0):
         await async_setup_component(hass, DOMAIN, config)
         await hass.async_block_till_done()
-        yield config_entry
+        yield config_entry, receive_message
 
 
 def load_nodes_state(fixture_path: str) -> dict:
@@ -151,7 +162,7 @@ def gps_sensor_state_fixture() -> dict:
 
 
 @pytest.fixture
-def gps_sensor(gateway_nodes, gps_sensor_state) -> Sensor:
+def gps_sensor(gateway_nodes: dict[int, Sensor], gps_sensor_state: dict) -> Sensor:
     """Load the gps sensor."""
     nodes = update_gateway_nodes(gateway_nodes, gps_sensor_state)
     node = nodes[1]
@@ -165,8 +176,70 @@ def power_sensor_state_fixture() -> dict:
 
 
 @pytest.fixture
-def power_sensor(gateway_nodes, power_sensor_state) -> Sensor:
+def power_sensor(gateway_nodes: dict[int, Sensor], power_sensor_state: dict) -> Sensor:
     """Load the power sensor."""
     nodes = update_gateway_nodes(gateway_nodes, power_sensor_state)
     node = nodes[1]
     return node
+
+
+@pytest.fixture(name="energy_sensor_state", scope="session")
+def energy_sensor_state_fixture() -> dict:
+    """Load the energy sensor state."""
+    return load_nodes_state("mysensors/energy_sensor_state.json")
+
+
+@pytest.fixture
+def energy_sensor(
+    gateway_nodes: dict[int, Sensor], energy_sensor_state: dict
+) -> Sensor:
+    """Load the energy sensor."""
+    nodes = update_gateway_nodes(gateway_nodes, energy_sensor_state)
+    node = nodes[1]
+    return node
+
+
+@pytest.fixture(name="sound_sensor_state", scope="session")
+def sound_sensor_state_fixture() -> dict:
+    """Load the sound sensor state."""
+    return load_nodes_state("mysensors/sound_sensor_state.json")
+
+
+@pytest.fixture
+def sound_sensor(gateway_nodes: dict[int, Sensor], sound_sensor_state: dict) -> Sensor:
+    """Load the sound sensor."""
+    nodes = update_gateway_nodes(gateway_nodes, sound_sensor_state)
+    node = nodes[1]
+    return node
+
+
+@pytest.fixture(name="distance_sensor_state", scope="session")
+def distance_sensor_state_fixture() -> dict:
+    """Load the distance sensor state."""
+    return load_nodes_state("mysensors/distance_sensor_state.json")
+
+
+@pytest.fixture
+def distance_sensor(
+    gateway_nodes: dict[int, Sensor], distance_sensor_state: dict
+) -> Sensor:
+    """Load the distance sensor."""
+    nodes = update_gateway_nodes(gateway_nodes, distance_sensor_state)
+    node = nodes[1]
+    return node
+
+
+@pytest.fixture(name="temperature_sensor_state", scope="session")
+def temperature_sensor_state_fixture() -> dict:
+    """Load the temperature sensor state."""
+    return load_nodes_state("mysensors/temperature_sensor_state.json")
+
+
+@pytest.fixture
+def temperature_sensor(
+    gateway_nodes: dict[int, Sensor], temperature_sensor_state: dict
+) -> Sensor:
+    """Load the temperature sensor."""
+    nodes = update_gateway_nodes(gateway_nodes, temperature_sensor_state)
+    node = nodes[1]
+    return node