In certain case, temperature event are registred with an offset of one hour #52

custom_components/versatile_thermostat/climate.py

@@ -8,6 +8,7 @@ from datetime import timedelta, datetime
 
 import voluptuous as vol
 
+from homeassistant.util import dt as dt_util
 from homeassistant.core import (
     HomeAssistant,
     callback,
@@ -204,6 +205,11 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
     _last_temperature_mesure: datetime
     _last_ext_temperature_mesure: datetime
     _total_energy: float
+    _overpowering_state: bool
+    _window_state: bool
+    _motion_state: bool
+    _presence_state: bool
+    _security_state: bool
 
     def __init__(self, hass: HomeAssistant, unique_id, name, entry_infos) -> None:
         """Initialize the thermostat."""
@@ -256,6 +262,8 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
 
         self._total_energy = None
 
+        self._current_tz = dt_util.get_time_zone(self._hass.config.time_zone)
+
         self.post_init(entry_infos)
 
     def post_init(self, entry_infos):
@@ -366,8 +374,6 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             and self._device_power
         ):
             self._pmax_on = True
-            self._current_power = 0
-            self._current_power_max = 0
         else:
             _LOGGER.info("%s - Power management is not fully configured", self)
 
@@ -401,8 +407,8 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             or DEFAULT_SECURITY_DEFAULT_ON_PERCENT
         )
         self._minimal_activation_delay = entry_infos.get(CONF_MINIMAL_ACTIVATION_DELAY)
-        self._last_temperature_mesure = datetime.now()
+        self._last_temperature_mesure = datetime.now(tz=self._current_tz)
-        self._last_ext_temperature_mesure = datetime.now()
+        self._last_ext_temperature_mesure = datetime.now(tz=self._current_tz)
         self._security_state = False
         self._saved_hvac_mode = None
 
@@ -997,7 +1003,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         if self._is_over_climate:
             return None
         elif self._device_power:
-            return self._device_power * self._prop_algorithm.on_percent
+            return float(self._device_power * self._prop_algorithm.on_percent)
         else:
             return None
 
@@ -1006,6 +1012,21 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         """Returns the total energy calculated for this thermostast"""
         return self._total_energy
 
+    @property
+    def overpowering_state(self) -> bool | None:
+        """Get the overpowering_state"""
+        return self._overpowering_state
+
+    @property
+    def window_state(self) -> bool | None:
+        """Get the window_state"""
+        return self._window_state
+
+    @property
+    def motion_state(self) -> bool | None:
+        """Get the motion_state"""
+        return self._motion_state
+
     def turn_aux_heat_on(self) -> None:
         """Turn auxiliary heater on."""
         if self._is_over_climate and self._underlying_climate:
@@ -1145,7 +1166,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         ):
             self._last_temperature_mesure = (
                 self._last_ext_temperature_mesure
-            ) = datetime.now()
+            ) = datetime.now(tz=self._current_tz)
 
     def find_preset_temp(self, preset_mode):
         """Find the right temperature of a preset considering the presence if configured"""
@@ -1294,8 +1315,6 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             self._hvac_mode,
             self._saved_hvac_mode,
         )
-        if new_state is None or old_state is None or new_state.state == old_state.state:
-            return
 
         # Check delay condition
         async def try_window_condition(_):
@@ -1313,6 +1332,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 _LOGGER.debug(
                     "Window delay condition is not satisfied. Ignore window event"
                 )
+                self._window_state = old_state.state
                 return
 
             _LOGGER.debug("%s - Window delay condition is satisfied", self)
@@ -1335,12 +1355,17 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 await self.async_set_hvac_mode(HVACMode.OFF)
             self.update_custom_attributes()
 
+        if new_state is None or old_state is None or new_state.state == old_state.state:
+            return try_window_condition
+
         if self._window_call_cancel:
             self._window_call_cancel()
             self._window_call_cancel = None
         self._window_call_cancel = async_call_later(
             self.hass, timedelta(seconds=self._window_delay_sec), try_window_condition
         )
+        # For testing purpose we need to access the inner function
+        return try_window_condition
 
     @callback
     async def _async_motion_changed(self, event):
@@ -1455,9 +1480,20 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             if math.isnan(cur_temp) or math.isinf(cur_temp):
                 raise ValueError(f"Sensor has illegal state {state.state}")
             self._cur_temp = cur_temp
+
             self._last_temperature_mesure = (
-                state.last_changed if state.last_changed is not None else datetime.now()
+                state.last_changed.astimezone(self._current_tz)
+                if state.last_changed is not None
+                else datetime.now(tz=self._current_tz)
             )
+
+            _LOGGER.debug(
+                "%s - After setting _last_temperature_mesure %s , state.last_changed.replace=%s",
+                self,
+                self._last_temperature_mesure,
+                state.last_changed.astimezone(self._current_tz),
+            )
+
             # try to restart if we were in security mode
             if self._security_state:
                 await self.check_security()
@@ -1474,8 +1510,18 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 raise ValueError(f"Sensor has illegal state {state.state}")
             self._cur_ext_temp = cur_ext_temp
             self._last_ext_temperature_mesure = (
-                state.last_changed if state.last_changed is not None else datetime.now()
+                state.last_changed.astimezone(self._current_tz)
+                if state.last_changed is not None
+                else datetime.now(tz=self._current_tz)
             )
+
+            _LOGGER.debug(
+                "%s - After setting _last_ext_temperature_mesure %s , state.last_changed.replace=%s",
+                self,
+                self._last_ext_temperature_mesure,
+                state.last_changed.astimezone(self._current_tz),
+            )
+
             # try to restart if we were in security mode
             if self._security_state:
                 await self.check_security()
@@ -1696,7 +1742,20 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         """
 
         if not self._pmax_on:
-            return
+            _LOGGER.debug(
+                "%s - power not configured. check_overpowering not available", self
+            )
+            return False
+
+        if (
+            self._current_power is None
+            or self._device_power is None
+            or self._current_power_max is None
+        ):
+            _LOGGER.warning(
+                "%s - power not valued. check_overpowering not available", self
+            )
+            return False
 
         _LOGGER.debug(
             "%s - overpowering check: power=%.3f, max_power=%.3f heater power=%.3f",
@@ -1705,6 +1764,7 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             self._current_power_max,
             self._device_power,
         )
+
         ret = self._current_power + self._device_power >= self._current_power_max
         if not self._overpowering_state and ret and not self._hvac_mode == HVACMode.OFF:
             _LOGGER.warning(
@@ -1755,12 +1815,12 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
 
     async def check_security(self) -> bool:
         """Check if last temperature date is too long"""
-        now = datetime.now()
+        now = datetime.now(self._current_tz)
         delta_temp = (
-            now - self._last_temperature_mesure.replace(tzinfo=None)
+            now - self._last_temperature_mesure.replace(tzinfo=self._current_tz)
         ).total_seconds() / 60.0
         delta_ext_temp = (
-            now - self._last_ext_temperature_mesure.replace(tzinfo=None)
+            now - self._last_ext_temperature_mesure.replace(tzinfo=self._current_tz)
         ).total_seconds() / 60.0
 
         mode_cond = self._is_over_climate or self._hvac_mode != HVACMode.OFF
@@ -1821,8 +1881,12 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             self.send_event(
                 EventType.TEMPERATURE_EVENT,
                 {
-                    "last_temperature_mesure": self._last_temperature_mesure.isoformat(),
+                    "last_temperature_mesure": self._last_temperature_mesure.replace(
-                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.isoformat(),
+                        tzinfo=self._current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.replace(
+                        tzinfo=self._current_tz
+                    ).isoformat(),
                     "current_temp": self._cur_temp,
                     "current_ext_temp": self._cur_ext_temp,
                     "target_temp": self.target_temperature,
@@ -1844,8 +1908,12 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 EventType.SECURITY_EVENT,
                 {
                     "type": "start",
-                    "last_temperature_mesure": self._last_temperature_mesure.isoformat(),
+                    "last_temperature_mesure": self._last_temperature_mesure.replace(
-                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.isoformat(),
+                        tzinfo=self._current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.replace(
+                        tzinfo=self._current_tz
+                    ).isoformat(),
                     "current_temp": self._cur_temp,
                     "current_ext_temp": self._cur_ext_temp,
                     "target_temp": self.target_temperature,
@@ -1874,8 +1942,12 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
                 EventType.SECURITY_EVENT,
                 {
                     "type": "end",
-                    "last_temperature_mesure": self._last_temperature_mesure.isoformat(),
+                    "last_temperature_mesure": self._last_temperature_mesure.replace(
-                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.isoformat(),
+                        tzinfo=self._current_tz
+                    ).isoformat(),
+                    "last_ext_temperature_mesure": self._last_ext_temperature_mesure.replace(
+                        tzinfo=self._current_tz
+                    ).isoformat(),
                     "current_temp": self._cur_temp,
                     "current_ext_temp": self._cur_ext_temp,
                     "target_temp": self.target_temperature,
@@ -2055,7 +2127,8 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
         """Update the custom extra attributes for the entity"""
 
         self._attr_extra_state_attributes: dict(str, str) = {
-            "hvac_mode": self._hvac_mode,
+            "hvac_mode": self.hvac_mode,
+            "preset_mode": self.preset_mode,
             "type": self._thermostat_type,
             "eco_temp": self._presets[PRESET_ECO],
             "boost_temp": self._presets[PRESET_BOOST],
@@ -2083,14 +2156,21 @@ class VersatileThermostat(ClimateEntity, RestoreEntity):
             "security_delay_min": self._security_delay_min,
             "security_min_on_percent": self._security_min_on_percent,
             "security_default_on_percent": self._security_default_on_percent,
-            "last_temperature_datetime": self._last_temperature_mesure.isoformat(),
+            "last_temperature_datetime": self._last_temperature_mesure.astimezone(
-            "last_ext_temperature_datetime": self._last_ext_temperature_mesure.isoformat(),
+                self._current_tz
+            ).isoformat(),
+            "last_ext_temperature_datetime": self._last_ext_temperature_mesure.astimezone(
+                self._current_tz
+            ).isoformat(),
             "security_state": self._security_state,
             "minimal_activation_delay_sec": self._minimal_activation_delay,
             "device_power": self._device_power,
             ATTR_MEAN_POWER_CYCLE: self.mean_cycle_power,
             ATTR_TOTAL_ENERGY: self.total_energy,
-            "last_update_datetime": datetime.now().isoformat(),
+            "last_update_datetime": datetime.now()
+            .astimezone(self._current_tz)
+            .isoformat(),
+            "timezone": str(self._current_tz),
         }
         if self._is_over_climate:
             self._attr_extra_state_attributes[

custom_components/versatile_thermostat/prop_algorithm.py

@@ -1,3 +1,4 @@
+""" The TPI calculation module """
 import logging
 
 _LOGGER = logging.getLogger(__name__)
@@ -21,7 +22,7 @@ class PropAlgorithm:
         tpi_coef_ext,
         cycle_min: int,
         minimal_activation_delay: int,
-    ):
+    ) -> None:
         """Initialisation of the Proportional Algorithm"""
         _LOGGER.debug(
             "Creation new PropAlgorithm function_type: %s, tpi_coef_int: %s, tpi_coef_ext: %s, cycle_min:%d, minimal_activation_delay:%d",

custom_components/versatile_thermostat/tests/commons.py

@@ -2,11 +2,12 @@
 from unittest.mock import patch
 
 from homeassistant.core import HomeAssistant, Event, EVENT_STATE_CHANGED, State
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import UnitOfTemperature, STATE_ON, STATE_OFF
 
 from homeassistant.config_entries import ConfigEntryState
-from pytest_homeassistant_custom_component.common import MockConfigEntry
+from homeassistant.util import dt as dt_util
 from homeassistant.helpers.entity_component import EntityComponent
+from pytest_homeassistant_custom_component.common import MockConfigEntry
 
 from ..climate import VersatileThermostat
 from ..const import *
@@ -113,4 +114,67 @@ async def send_temperature_change_event(entity: VersatileThermostat, new_temp, d
             )
         },
     )
-    await entity._async_temperature_changed(temp_event)
+    return await entity._async_temperature_changed(temp_event)
+
+
+async def send_power_change_event(entity: VersatileThermostat, new_power, date):
+    """Sending a new power event simulating a change on power sensor"""
+    power_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=new_power,
+                last_changed=date,
+                last_updated=date,
+            )
+        },
+    )
+    return await entity._async_power_changed(power_event)
+
+
+async def send_max_power_change_event(entity: VersatileThermostat, new_power_max, date):
+    """Sending a new power max event simulating a change on power max sensor"""
+    power_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=new_power_max,
+                last_changed=date,
+                last_updated=date,
+            )
+        },
+    )
+    return await entity._async_max_power_changed(power_event)
+
+
+async def send_window_change_event(
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+):
+    """Sending a new window event simulating a change on the window state"""
+    window_event = Event(
+        EVENT_STATE_CHANGED,
+        {
+            "new_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if new_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+            "old_state": State(
+                entity_id=entity.entity_id,
+                state=STATE_ON if old_state else STATE_OFF,
+                last_changed=date,
+                last_updated=date,
+            ),
+        },
+    )
+    ret = await entity._async_windows_changed(window_event)
+    return ret
+
+
+def get_tz(hass):
+    """Get the current timezone"""
+
+    return dt_util.get_time_zone(hass.config.time_zone)

custom_components/versatile_thermostat/tests/test_power.py

@@ -0,0 +1,346 @@
+""" Test the Power management """
+from unittest.mock import patch, call
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from datetime import datetime
+
+import logging
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+async def test_power_management_hvac_off(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test the Power management"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: True,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_POWER_SENSOR: "sensor.mock_power_sensor",
+            CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
+            CONF_DEVICE_POWER: 100,
+            CONF_PRESET_POWER: "eco",
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tpi_algo = entity._prop_algorithm
+    assert tpi_algo
+
+    await entity.async_set_preset_mode(PRESET_BOOST)
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.target_temperature == 19
+    assert entity.overpowering_state is None
+    assert entity.hvac_mode == HVACMode.OFF
+
+    # Send power mesurement
+    await send_power_change_event(entity, 50, datetime.now())
+    assert await entity.check_overpowering() is False
+
+    # All configuration is not complete
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is None
+
+    # Send power max mesurement
+    await send_max_power_change_event(entity, 300, datetime.now())
+    assert await entity.check_overpowering() is False
+    # All configuration is complete and power is < power_max
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is False
+
+    # Send power max mesurement too low but HVACMode is off
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_max_power_change_event(entity, 149, datetime.now())
+        assert await entity.check_overpowering() is True
+        # All configuration is complete and power is > power_max but we stay in Boost cause thermostat if Off
+        assert entity.preset_mode is PRESET_BOOST
+        assert entity.overpowering_state is True
+
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+
+async def test_power_management_hvac_on(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test the Power management"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: True,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_POWER_SENSOR: "sensor.mock_power_sensor",
+            CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
+            CONF_DEVICE_POWER: 100,
+            CONF_PRESET_POWER: 12,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tpi_algo = entity._prop_algorithm
+    assert tpi_algo
+
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await entity.async_set_preset_mode(PRESET_BOOST)
+    assert entity.hvac_mode is HVACMode.HEAT
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is None
+    assert entity.target_temperature == 19
+
+    # Send power mesurement
+    await send_power_change_event(entity, 50, datetime.now())
+    # Send power max mesurement
+    await send_max_power_change_event(entity, 300, datetime.now())
+    assert await entity.check_overpowering() is False
+    # All configuration is complete and power is < power_max
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is False
+
+    # Send power max mesurement too low and HVACMode is on
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_max_power_change_event(entity, 149, datetime.now())
+        assert await entity.check_overpowering() is True
+        # All configuration is complete and power is > power_max we switch to POWER preset
+        assert entity.preset_mode is PRESET_POWER
+        assert entity.overpowering_state is True
+        assert entity.target_temperature == 12
+
+        assert mock_send_event.call_count == 2
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_POWER}),
+                call.send_event(
+                    EventType.POWER_EVENT,
+                    {
+                        "type": "start",
+                        "current_power": 50,
+                        "device_power": 100,
+                        "current_power_max": 149,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 1
+
+    # Send power mesurement low to unseet power preset
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_power_change_event(entity, 48, datetime.now())
+        assert await entity.check_overpowering() is False
+        # All configuration is complete and power is < power_max, we restore previous preset
+        assert entity.preset_mode is PRESET_BOOST
+        assert entity.overpowering_state is False
+        assert entity.target_temperature == 19
+
+        assert mock_send_event.call_count == 2
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_BOOST}),
+                call.send_event(
+                    EventType.POWER_EVENT,
+                    {
+                        "type": "end",
+                        "current_power": 48,
+                        "device_power": 100,
+                        "current_power_max": 149,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
+        # No current temperature is set so the heater wont be turned on
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+
+async def test_power_management_energy(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test the Power management energy mesurement"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: False,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: True,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_POWER_SENSOR: "sensor.mock_power_sensor",
+            CONF_MAX_POWER_SENSOR: "sensor.mock_power_max_sensor",
+            CONF_DEVICE_POWER: 100,
+            CONF_PRESET_POWER: 12,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tpi_algo = entity._prop_algorithm
+    assert tpi_algo
+
+    assert entity.total_energy == 0
+
+    # set temperature to 15 so that on_percent will be set
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_temperature_change_event(entity, 15, datetime.now())
+        await entity.async_set_hvac_mode(HVACMode.HEAT)
+        await entity.async_set_preset_mode(PRESET_BOOST)
+
+        assert entity.hvac_mode is HVACMode.HEAT
+        assert entity.preset_mode is PRESET_BOOST
+        assert entity.target_temperature == 19
+        assert entity.current_temperature == 15
+        assert tpi_algo.on_percent == 1
+
+        assert entity.mean_cycle_power == 100.0
+
+        assert mock_send_event.call_count == 2
+        assert mock_heater_on.call_count == 1
+        assert mock_heater_off.call_count == 0
+
+    entity.incremente_energy()
+    assert entity.total_energy == 100 * 5 / 60.0
+    entity.incremente_energy()
+    assert entity.total_energy == 2 * 100 * 5 / 60.0
+
+    # change temperature to a higher value
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_temperature_change_event(entity, 18, datetime.now())
+        assert tpi_algo.on_percent == 0.3
+        assert entity.mean_cycle_power == 30.0
+
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+    entity.incremente_energy()
+    assert round(entity.total_energy, 2) == round((2.0 + 0.3) * 100 * 5 / 60.0, 2)
+
+    entity.incremente_energy()
+    assert round(entity.total_energy, 2) == round((2.0 + 0.6) * 100 * 5 / 60.0, 2)
+
+    # change temperature to a much higher value so that heater will be shut down
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off:
+        await send_temperature_change_event(entity, 20, datetime.now())
+        assert tpi_algo.on_percent == 0.0
+        assert entity.mean_cycle_power == 0.0
+
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+    entity.incremente_energy()
+    # No change on energy
+    assert round(entity.total_energy, 2) == round((2.0 + 0.6) * 100 * 5 / 60.0, 2)
+
+    # Still no change
+    entity.incremente_energy()
+    assert round(entity.total_energy, 2) == round((2.0 + 0.6) * 100 * 5 / 60.0, 2)

custom_components/versatile_thermostat/tests/test_security.py

@@ -19,6 +19,8 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     6. check that security is off and preset is changed to boost
     """
 
+    tz = get_tz(hass)
+
     entry = MockConfigEntry(
         domain=DOMAIN,
         title="TheOverSwitchMockName",
@@ -50,7 +52,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     )
 
     # 1. creates a thermostat and check that security is off
-    now: datetime = datetime.now()
+    now: datetime = datetime.now(tz=tz)
     entity: VersatileThermostat = await create_thermostat(
         hass, entry, "climate.theoverswitchmockname"
     )
@@ -66,8 +68,10 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     ]
     assert entity._last_ext_temperature_mesure is not None
     assert entity._last_temperature_mesure is not None
-    assert (entity._last_temperature_mesure - now).total_seconds() < 1
+    assert (entity._last_temperature_mesure.astimezone(tz) - now).total_seconds() < 1
-    assert (entity._last_ext_temperature_mesure - now).total_seconds() < 1
+    assert (
+        entity._last_ext_temperature_mesure.astimezone(tz) - now
+    ).total_seconds() < 1
 
     # set a preset
     assert entity.preset_mode is PRESET_NONE
@@ -166,8 +170,12 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
                     EventType.SECURITY_EVENT,
                     {
                         "type": "end",
-                        "last_temperature_mesure": event_timestamp.isoformat(),
+                        "last_temperature_mesure": event_timestamp.astimezone(
-                        "last_ext_temperature_mesure": entity._last_ext_temperature_mesure.isoformat(),
+                            tz
+                        ).isoformat(),
+                        "last_ext_temperature_mesure": entity._last_ext_temperature_mesure.astimezone(
+                            tz
+                        ).isoformat(),
                         "current_temp": 15.2,
                         "current_ext_temp": None,
                         "target_temp": 19,

custom_components/versatile_thermostat/tests/test_tpi.py

@@ -46,7 +46,7 @@ async def test_tpi_calculation(hass: HomeAssistant, skip_hass_states_is_state):
     assert tpi_algo.calculated_on_percent == 1
     assert tpi_algo.on_time_sec == 300
     assert tpi_algo.off_time_sec == 0
-    assert entity.mean_cycle_power is None
+    assert entity.mean_cycle_power is None  # no device power configured
 
     tpi_algo.calculate(15, 14, 5)
     assert tpi_algo.on_percent == 0.4

custom_components/versatile_thermostat/tests/test_window.py

@@ -0,0 +1,200 @@
+""" Test the Window management """
+from unittest.mock import patch, call
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from datetime import datetime
+import time
+
+import logging
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+async def test_window_management_time_not_enough(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test the Power management"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: True,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_WINDOW_SENSOR: "binary_sensor.mock_window_sensor",
+            CONF_WINDOW_DELAY: 0,  # important to not been obliged to wait
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tpi_algo = entity._prop_algorithm
+    assert tpi_algo
+
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await entity.async_set_preset_mode(PRESET_BOOST)
+    assert entity.hvac_mode is HVACMode.HEAT
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is None
+    assert entity.target_temperature == 19
+
+    assert entity.window_state is None
+
+    # Open the window, but condition of time is not satisfied and check the thermostat don't turns off
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=False
+    ) as mock_condition:
+        await send_temperature_change_event(entity, 15, datetime.now())
+        try_window_condition = await send_window_change_event(
+            entity, True, False, datetime.now()
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 1
+        assert mock_heater_off.call_count == 0
+        assert mock_condition.call_count == 1
+
+        assert entity.window_state == STATE_OFF
+
+        # Close the window
+        try_window_condition = await send_window_change_event(
+            entity, False, False, datetime.now()
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+        assert entity.window_state == STATE_OFF
+
+
+async def test_window_management_time_enough(
+    hass: HomeAssistant, skip_hass_states_is_state
+):
+    """Test the Power management"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOverSwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOverSwitchMockName",
+            CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_SWITCH,
+            CONF_TEMP_SENSOR: "sensor.mock_temp_sensor",
+            CONF_EXTERNAL_TEMP_SENSOR: "sensor.mock_ext_temp_sensor",
+            CONF_CYCLE_MIN: 5,
+            CONF_TEMP_MIN: 15,
+            CONF_TEMP_MAX: 30,
+            "eco_temp": 17,
+            "comfort_temp": 18,
+            "boost_temp": 19,
+            CONF_USE_WINDOW_FEATURE: True,
+            CONF_USE_MOTION_FEATURE: False,
+            CONF_USE_POWER_FEATURE: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch",
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_WINDOW_SENSOR: "binary_sensor.mock_window_sensor",
+            CONF_WINDOW_DELAY: 0,  # important to not been obliged to wait
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    tpi_algo = entity._prop_algorithm
+    assert tpi_algo
+
+    await entity.async_set_hvac_mode(HVACMode.HEAT)
+    await entity.async_set_preset_mode(PRESET_BOOST)
+    assert entity.hvac_mode is HVACMode.HEAT
+    assert entity.preset_mode is PRESET_BOOST
+    assert entity.overpowering_state is None
+    assert entity.target_temperature == 19
+
+    assert entity.window_state is None
+
+    # Open the window, but condition of time is not satisfied and check the thermostat don't turns off
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=True
+    ) as mock_condition, patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
+        return_value=True,
+    ):
+        await send_temperature_change_event(entity, 15, datetime.now())
+        try_window_condition = await send_window_change_event(
+            entity, True, False, datetime.now()
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        assert mock_send_event.call_count == 1
+        mock_send_event.assert_has_calls(
+            [call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF})]
+        )
+        assert mock_heater_on.call_count == 1
+        # One call in turn_oiff and one call in the control_heating
+        assert mock_heater_off.call_count == 2
+        assert mock_condition.call_count == 1
+
+        assert entity.window_state == STATE_ON
+
+        # Close the window
+        try_window_condition = await send_window_change_event(
+            entity, False, True, datetime.now()
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+        assert entity.window_state == STATE_OFF
+        assert mock_heater_on.call_count == 2
+        assert mock_send_event.call_count == 2
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF}),
+                call.send_event(
+                    EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.HEAT}
+                ),
+            ],
+            any_order=False,
+        )
+        assert entity.preset_mode is PRESET_BOOST