Merge pull request #603 from canton7/feature/snapshot

Introduce snapshot testing of entities

.devcontainer/setup

@@ -4,6 +4,9 @@ set -e
 
 cd "$(dirname "$0")/.."
 
-python3 -m pip install --requirement requirements.txt
+python3 -m pip install -r requirements.txt
+# json files on syrupy are broken before 4.0.4, but pytest-homeassistant-custom-component for our current HA version
+# relies on 4.0.2
+python3 -m pip install --no-deps syrupy==4.0.4
 
 git config --global --fixed-value --replace-all safe.directory "${PWD}" "${PWD}"

.github/workflows/tests.yaml

@@ -29,6 +29,9 @@ jobs:
       - name: Install Python modules
         run: |
           pip install --no-cache-dir -r requirements.txt
+          # json files on syrupy are broken before 4.0.4, but pytest-homeassistant-custom-component for our current HA
+          # version relies on 4.0.2
+          pip install --no-deps syrupy==4.0.4
 
       - name: Run pre-commit on all files
         run: |

.prettierignore

@@ -0,0 +1 @@
+tests/__snapshots__

.vscode/tasks.json

@@ -12,6 +12,12 @@
       "type": "shell",
       "command": "pre-commit run --all-files --color=always",
       "problemMatcher": []
+    },
+    {
+      "label": "Update snapshots",
+      "type": "shell",
+      "command": "pytest --snapshot-update",
+      "problemMatcher": []
     }
   ]
 }

custom_components/foxess_modbus/entities/entity_factory.py

@@ -2,6 +2,7 @@
 
 from abc import ABC
 from abc import abstractmethod
+from typing import Any
 from typing import Sequence
 
 from homeassistant.helpers.entity import Entity
@@ -49,6 +50,10 @@ def create_entity_if_supported(
     ) -> Entity | None:
         """Instantiate a new entity. The returned type must match self.entity_type"""
 
+    @abstractmethod
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        """Serialize to a dict, used for snapshot testing."""
+
     def _supports_inverter_model(
         self,
         address_specs: Sequence[InverterModelSpec],
@@ -116,3 +121,19 @@ def _addresses_for_inverter_model(
                 ), f"{self}: more than one address spec defined for ({inverter_model}, {register_type})"
                 result = addresses
         return result
+
+    def _addresses_for_serialization(
+        self, address_specs: Sequence[InverterModelSpec], inverter_model: Inv
+    ) -> dict[str, list[int] | None] | None:
+        result: dict[str, list[int] | None] | None = None
+        for spec in address_specs:
+            address_type_map = spec.address_type_map_for_inverter_model(inverter_model)
+            for k, v in address_type_map.items():
+                if result is None:
+                    result = {}
+
+                key = k.name.lower()
+                assert key not in result
+                result[key] = v
+
+        return result

custom_components/foxess_modbus/entities/inverter_model_spec.py

@@ -10,6 +10,13 @@
 class InverterModelSpec(ABC):
     """Base class for specifications which describe which inverter models an entity supports"""
 
+    @abstractmethod
+    def address_type_map_for_inverter_model(self, models: Inv) -> dict[RegisterType, list[int] | None]:
+        """
+        If this spec supports the given inverter model (e.g. "H1", return the dict of register type -> addresses)
+        which it cares about (or an empty dict if it doesn't rely on any addresses).
+        """
+
     @abstractmethod
     def addresses_for_inverter_model(self, *, register_type: RegisterType, models: Inv) -> list[int] | None:
         """
@@ -32,6 +39,11 @@ def __init__(self, addresses: dict[RegisterType, list[int] | None], models: Inv)
         self._addresses = addresses
         self._models = models
 
+    def address_type_map_for_inverter_model(self, models: Inv) -> dict[RegisterType, list[int] | None]:
+        if models not in self._models:
+            return {}
+        return self._addresses
+
     def addresses_for_inverter_model(self, *, register_type: RegisterType, models: Inv) -> list[int] | None:
         if models not in self._models:
             return None
@@ -81,5 +93,10 @@ def __init__(self, register_types: list[RegisterType], models: Inv) -> None:
         self._register_types = register_types
         self._models = models
 
+    def address_type_map_for_inverter_model(self, models: Inv) -> dict[RegisterType, list[int] | None]:
+        if models not in self._models:
+            return {}
+        return {x: None for x in self._register_types}
+
     def addresses_for_inverter_model(self, register_type: RegisterType, models: Inv) -> list[int] | None:
         return [] if register_type in self._register_types and models in self._models else None

custom_components/foxess_modbus/entities/modbus_binary_sensor.py

@@ -3,6 +3,7 @@
 import logging
 from dataclasses import dataclass
 from dataclasses import field
+from typing import Any
 from typing import Callable
 from typing import cast
 
@@ -44,6 +45,18 @@ def create_entity_if_supported(
         address = self._address_for_inverter_model(self.address, inverter_model, register_type)
         return ModbusBinarySensor(controller, self, address) if address is not None else None
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.address, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "binary-sensor",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+        }
+
 
 class ModbusBinarySensor(ModbusEntityMixin, BinarySensorEntity):
     """Modbus binary sensor"""

custom_components/foxess_modbus/entities/modbus_charge_period_sensors.py

@@ -4,6 +4,7 @@
 from dataclasses import dataclass
 from dataclasses import field
 from datetime import time
+from typing import Any
 from typing import cast
 
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
@@ -86,6 +87,19 @@ def create_entity_if_supported(
         ), f"{self}: address is {address} but other_address is None for ({inverter_model}, {register_type})"
         return ModbusChargePeriodStartEndSensor(controller, self, address, other_address)
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.address, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "charge-period-time",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+            "other_addresses": self._addresses_for_serialization(self.other_address, inverter_model),
+        }
+
 
 class ModbusChargePeriodStartEndSensor(ModbusEntityMixin, RestoreEntity, SensorEntity):
     """Sensor used for the start/end of a charge time period"""
@@ -212,6 +226,20 @@ def create_entity_if_supported(
             period_end_address,
         )
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        start_address_map = self._addresses_for_serialization(self.period_start_address, inverter_model)
+        end_address_map = self._addresses_for_serialization(self.period_end_address, inverter_model)
+        if start_address_map is None or end_address_map is None:
+            return None
+
+        return {
+            "type": "charge-period-enabled",
+            "key": self.key,
+            "name": self.name,
+            "start_addresses": start_address_map,
+            "end_addresses": end_address_map,
+        }
+
 
 class ModbusEnableForceChargeSensor(ModbusEntityMixin, BinarySensorEntity):
     """Sensor which synthesises an "enable force charge" state, based on the start/end time registers"""

custom_components/foxess_modbus/entities/modbus_fault_sensor.py

@@ -1,6 +1,7 @@
 """Decodes the fault registers"""
 
 from dataclasses import dataclass
+from typing import Any
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.components.sensor import SensorEntityDescription
@@ -176,6 +177,19 @@ def create_entity_if_supported(
         addresses = self._addresses_for_inverter_model(self.addresses, inverter_model, register_type)
         return ModbusFaultSensor(controller, self, addresses) if addresses is not None else None
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.addresses, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "fault-sensor",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+            "faults": _FAULTS,
+        }
+
 
 class ModbusFaultSensor(ModbusEntityMixin, SensorEntity):
     """Sensor class."""

custom_components/foxess_modbus/entities/modbus_integration_sensor.py

@@ -2,6 +2,7 @@
 
 import logging
 from dataclasses import dataclass
+from typing import Any
 from typing import cast
 
 from homeassistant.components.integration.sensor import DEFAULT_ROUND
@@ -59,6 +60,21 @@ def create_entity_if_supported(
             unit_time=self.unit_time,
         )
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.models, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "integration-sensor",
+            "key": self.key,
+            "name": self.name,
+            "register_types": address_map.keys(),
+            "method": self.integration_method,
+            "source": self.source_entity,
+            "unit_time": self.unit_time,
+        }
+
 
 class ModbusIntegrationSensor(ModbusEntityMixin, IntegrationSensor):
     """Sensor class."""

custom_components/foxess_modbus/entities/modbus_inverter_state_sensor.py

@@ -1,6 +1,7 @@
 """Decodes the fault registers"""
 
 from dataclasses import dataclass
+from typing import Any
 from typing import cast
 
 from homeassistant.components.sensor import SensorDeviceClass
@@ -58,6 +59,19 @@ def create_entity_if_supported(
         address = self._address_for_inverter_model(self.address, inverter_model, register_type)
         return ModbusInverterStateSensor(controller, self, address) if address is not None else None
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.address, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "inverter-state-sensor",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+            "states": self.states,
+        }
+
 
 class ModbusInverterStateSensor(ModbusEntityMixin, SensorEntity):
     """Sensor class."""
@@ -109,6 +123,18 @@ def create_entity_if_supported(
         addresses = self._addresses_for_inverter_model(self.addresses, inverter_model, register_type)
         return ModbusG2InverterStateSensor(controller, self, addresses) if addresses is not None else None
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.addresses, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "inverter-state-sensor",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+        }
+
 
 class ModbusG2InverterStateSensor(ModbusEntityMixin, SensorEntity):
     """Sensor class."""

custom_components/foxess_modbus/entities/modbus_lambda_sensor.py

@@ -55,6 +55,19 @@ def create_entity_if_supported(
             method=self.method,
         )
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.models, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "lambda",
+            "key": self.key,
+            "name": self.name,
+            "register_types": address_map.keys(),
+            "sources": self.sources,
+        }
+
 
 class ModbusLambdaSensor(ModbusEntityMixin, SensorEntity):
     """Generates a value by applying a lambda to the values of a number of other sensors"""

custom_components/foxess_modbus/entities/modbus_number.py

@@ -3,6 +3,7 @@
 import logging
 from dataclasses import dataclass
 from dataclasses import field
+from typing import Any
 from typing import Callable
 from typing import cast
 
@@ -47,6 +48,19 @@ def create_entity_if_supported(
         address = self._address_for_inverter_model(self.address, inverter_model, register_type)
         return ModbusNumber(controller, self, address) if address is not None else None
 
+    def serialize(self, inverter_model: Inv) -> dict[str, Any] | None:
+        address_map = self._addresses_for_serialization(self.address, inverter_model)
+        if address_map is None:
+            return None
+
+        return {
+            "type": "number",
+            "key": self.key,
+            "name": self.name,
+            "addresses": address_map,
+            "scale": self.scale,
+        }
+
 
 class ModbusNumber(ModbusEntityMixin, NumberEntity):
     """Number class"""

custom_components/foxess_modbus/entities/modbus_remote_control_number.py

@@ -2,6 +2,7 @@
 
 import logging
 from dataclasses import dataclass
+from typing import Any
 from typing import Callable
 from typing import cast
 
@@ -57,6 +58,9 @@ def create_entity_if_supported(
         )
         return ModbusRemoteControlNumber(controller, self, max_value_address)
 
+    def serialize(self, _inverter_model: Inv) -> dict[str, Any] | None:
+        return None
+
 
 class ModbusRemoteControlNumber(ModbusEntityMixin, RestoreNumber, NumberEntity):
     """Number class"""

custom_components/foxess_modbus/entities/modbus_remote_control_select.py

@@ -2,6 +2,7 @@
 
 import logging
 from dataclasses import dataclass
+from typing import Any
 
 from homeassistant.components.select import SelectEntity
 from homeassistant.components.select import SelectEntityDescription
@@ -38,6 +39,9 @@ def create_entity_if_supported(
             return None
         return ModbusRemoteControlSelect(controller, self)
 
+    def serialize(self, _inverter_model: Inv) -> dict[str, Any] | None:
+        return None
+
 
 class ModbusRemoteControlSelect(ModbusEntityMixin, SelectEntity):
     def __init__(