Release 3.2 beta1 - an error in multi-testu

.devcontainer/configuration.yaml

@@ -3,7 +3,9 @@ default_config:
 logger:
   default: info
   logs:
-    custom_components.versatile_thermostat: debug
+    custom_components.versatile_thermostat: info
+    custom_components.versatile_thermostat.underlyings: debug
+    custom_components.versatile_thermostat.climate: debug
 
 # If you need to debug uncommment the line below (doc: https://www.home-assistant.io/integrations/debugpy/)
 debugpy:
@@ -52,11 +54,17 @@ input_boolean:
   fake_heater_switch1:
     name: Heater 1 (Linear)
     icon: mdi:radiator
-  fake_heater_switch2:
-    name: Heater (TPI with presence preset)
+  fake_heater_4switch1:
+    name: Heater (multiswitch1)
     icon: mdi:radiator
-  fake_heater_switch3:
-    name: Heater (TPI with offset)
+  fake_heater_4switch2:
+    name: Heater (multiswitch2)
+    icon: mdi:radiator
+  fake_heater_4switch3:
+    name: Heater (multiswitch3)
+    icon: mdi:radiator
+  fake_heater_4switch4:
+    name: Heater (multiswitch4)
     icon: mdi:radiator
   # input_boolean to simulate the motion sensor entity. Only for development environment.
   fake_motion_sensor1:

custom_components/versatile_thermostat/commons.py

@@ -19,7 +19,7 @@ class VersatileThermostatBaseEntity(Entity):
     _my_climate: VersatileThermostat
     hass: HomeAssistant
     _config_id: str
-    _devince_name: str
+    _device_name: str
 
     def __init__(self, hass: HomeAssistant, config_id, device_name) -> None:
         """The CTOR"""

custom_components/versatile_thermostat/config_flow.py

@@ -41,6 +41,9 @@ from .const import (
     DOMAIN,
     CONF_NAME,
     CONF_HEATER,
+    CONF_HEATER_2,
+    CONF_HEATER_3,
+    CONF_HEATER_4,
     CONF_TEMP_SENSOR,
     CONF_EXTERNAL_TEMP_SENSOR,
     CONF_POWER_SENSOR,
@@ -224,6 +227,21 @@ class VersatileThermostatBaseConfigFlow(FlowHandler):
                         domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]
                     ),
                 ),
+                vol.Optional(CONF_HEATER_2): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]
+                    ),
+                ),
+                vol.Optional(CONF_HEATER_3): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]
+                    ),
+                ),
+                vol.Optional(CONF_HEATER_4): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=[SWITCH_DOMAIN, INPUT_BOOLEAN_DOMAIN]
+                    ),
+                ),
                 vol.Required(
                     CONF_PROP_FUNCTION, default=PROPORTIONAL_FUNCTION_TPI
                 ): vol.In(

custom_components/versatile_thermostat/const.py

@@ -30,6 +30,9 @@ DOMAIN = "versatile_thermostat"
 PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.BINARY_SENSOR, Platform.SENSOR]
 
 CONF_HEATER = "heater_entity_id"
+CONF_HEATER_2 = "heater_entity2_id"
+CONF_HEATER_3 = "heater_entity3_id"
+CONF_HEATER_4 = "heater_entity4_id"
 CONF_TEMP_SENSOR = "temperature_sensor_entity_id"
 CONF_EXTERNAL_TEMP_SENSOR = "external_temperature_sensor_entity_id"
 CONF_POWER_SENSOR = "power_sensor_entity_id"

custom_components/versatile_thermostat/strings.json

@@ -22,12 +22,23 @@
         }
       },
       "type": {
-        "title": "Linked entity",
-        "description": "Linked entity attributes",
+        "title": "Linked entities",
+        "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "Heater entity id",
+          "heater_entity_id": "Heater switch",
+          "heater_entity2_id": "2nd Heater switch",
+          "heater_entity3_id": "3rd Heater switch",
+          "heater_entity4_id": "4th Heater switch",
+          "proportional_function": "Algorithm",
+          "climate_entity_id": "Underlying thermostat"
+        },
+        "data_description": {
+          "heater_entity_id": "Mandatory heater entity id",
+          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
+          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
+          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying thermostat entity id"
+          "climate_entity_id": "Underlying climate entity id"
         }
       },
       "tpi": {
@@ -142,12 +153,23 @@
         }
       },
       "type": {
-        "title": "Linked entity",
-        "description": "Linked entity attributes",
+        "title": "Linked entities",
+        "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "Heater entity id",
+          "heater_entity_id": "Heater switch",
+          "heater_entity2_id": "2nd Heater switch",
+          "heater_entity3_id": "3rd Heater switch",
+          "heater_entity4_id": "4th Heater switch",
+          "proportional_function": "Algorithm",
+          "climate_entity_id": "Underlying thermostat"
+        },
+        "data_description": {
+          "heater_entity_id": "Mandatory heater entity id",
+          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
+          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
+          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying thermostat entity id"
+          "climate_entity_id": "Underlying climate entity id"
         }
       },
       "tpi": {

custom_components/versatile_thermostat/tests/commons.py

@@ -1,4 +1,6 @@
 """ Some common resources """
+import asyncio
+import logging
 from unittest.mock import patch, MagicMock
 
 from homeassistant.core import HomeAssistant, Event, EVENT_STATE_CHANGED, State
@@ -19,11 +21,14 @@ from pytest_homeassistant_custom_component.common import MockConfigEntry
 
 from ..climate import VersatileThermostat
 from ..const import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from ..underlyings import *  # pylint: disable=wildcard-import, unused-wildcard-import
 
 from .const import (  # pylint: disable=unused-import
     MOCK_TH_OVER_SWITCH_USER_CONFIG,
+    MOCK_TH_OVER_4SWITCH_USER_CONFIG,
     MOCK_TH_OVER_CLIMATE_USER_CONFIG,
     MOCK_TH_OVER_SWITCH_TYPE_CONFIG,
+    MOCK_TH_OVER_4SWITCH_TYPE_CONFIG,
     MOCK_TH_OVER_CLIMATE_TYPE_CONFIG,
     MOCK_TH_OVER_SWITCH_TPI_CONFIG,
     MOCK_PRESETS_CONFIG,
@@ -59,6 +64,20 @@ PARTIAL_CLIMATE_CONFIG = (
     | MOCK_ADVANCED_CONFIG
 )
 
+FULL_4SWITCH_CONFIG = (
+    MOCK_TH_OVER_4SWITCH_USER_CONFIG
+    | MOCK_TH_OVER_4SWITCH_TYPE_CONFIG
+    | MOCK_TH_OVER_SWITCH_TPI_CONFIG
+    | MOCK_PRESETS_CONFIG
+    | MOCK_WINDOW_CONFIG
+    | MOCK_MOTION_CONFIG
+    | MOCK_POWER_CONFIG
+    | MOCK_PRESENCE_CONFIG
+    | MOCK_ADVANCED_CONFIG
+)
+
+_LOGGER = logging.getLogger(__name__)
+
 
 class MockClimate(ClimateEntity):
     """A Mock Climate class used for Underlying climate mode"""
@@ -180,8 +199,16 @@ def search_entity(hass: HomeAssistant, entity_id, domain) -> Entity:
     return None
 
 
-async def send_temperature_change_event(entity: VersatileThermostat, new_temp, date):
+async def send_temperature_change_event(
+    entity: VersatileThermostat, new_temp, date, sleep=True
+):
     """Sending a new temperature event simulating a change on temperature sensor"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_temp=%.2f date=%s on %s",
+        new_temp,
+        date,
+        entity,
+    )
     temp_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -193,13 +220,21 @@ async def send_temperature_change_event(entity: VersatileThermostat, new_temp, d
             )
         },
     )
-    return await entity._async_temperature_changed(temp_event)
+    await entity._async_temperature_changed(temp_event)
+    if sleep:
+        await asyncio.sleep(0.1)
 
 
 async def send_ext_temperature_change_event(
-    entity: VersatileThermostat, new_temp, date
+    entity: VersatileThermostat, new_temp, date, sleep=True
 ):
     """Sending a new external temperature event simulating a change on temperature sensor"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_temp=%.2f date=%s on %s",
+        new_temp,
+        date,
+        entity,
+    )
     temp_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -211,11 +246,21 @@ async def send_ext_temperature_change_event(
             )
         },
     )
-    return await entity._async_ext_temperature_changed(temp_event)
+    await entity._async_ext_temperature_changed(temp_event)
+    if sleep:
+        await asyncio.sleep(0.1)
 
 
-async def send_power_change_event(entity: VersatileThermostat, new_power, date):
+async def send_power_change_event(
+    entity: VersatileThermostat, new_power, date, sleep=True
+):
     """Sending a new power event simulating a change on power sensor"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_power=%.2f date=%s on %s",
+        new_power,
+        date,
+        entity,
+    )
     power_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -227,11 +272,21 @@ async def send_power_change_event(entity: VersatileThermostat, new_power, date):
             )
         },
     )
-    return await entity._async_power_changed(power_event)
+    await entity._async_power_changed(power_event)
+    if sleep:
+        await asyncio.sleep(0.1)
 
 
-async def send_max_power_change_event(entity: VersatileThermostat, new_power_max, date):
+async def send_max_power_change_event(
+    entity: VersatileThermostat, new_power_max, date, sleep=True
+):
     """Sending a new power max event simulating a change on power max sensor"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_power_max=%.2f date=%s on %s",
+        new_power_max,
+        date,
+        entity,
+    )
     power_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -243,13 +298,22 @@ async def send_max_power_change_event(entity: VersatileThermostat, new_power_max
             )
         },
     )
-    return await entity._async_max_power_changed(power_event)
+    await entity._async_max_power_changed(power_event)
+    if sleep:
+        await asyncio.sleep(0.1)
 
 
 async def send_window_change_event(
-    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date, sleep=True
 ):
     """Sending a new window event simulating a change on the window state"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_state=%s old_state=%s date=%s on %s",
+        new_state,
+        old_state,
+        date,
+        entity,
+    )
     window_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -268,13 +332,22 @@ async def send_window_change_event(
         },
     )
     ret = await entity._async_windows_changed(window_event)
+    if sleep:
+        await asyncio.sleep(0.1)
     return ret
 
 
 async def send_motion_change_event(
-    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date, sleep=True
 ):
     """Sending a new motion event simulating a change on the window state"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_state=%s old_state=%s date=%s on %s",
+        new_state,
+        old_state,
+        date,
+        entity,
+    )
     motion_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -293,13 +366,22 @@ async def send_motion_change_event(
         },
     )
     ret = await entity._async_motion_changed(motion_event)
+    if sleep:
+        await asyncio.sleep(0.1)
     return ret
 
 
 async def send_presence_change_event(
-    entity: VersatileThermostat, new_state: bool, old_state: bool, date
+    entity: VersatileThermostat, new_state: bool, old_state: bool, date, sleep=True
 ):
     """Sending a new presence event simulating a change on the window state"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_state=%s old_state=%s date=%s on %s",
+        new_state,
+        old_state,
+        date,
+        entity,
+    )
     presence_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -318,6 +400,8 @@ async def send_presence_change_event(
         },
     )
     ret = await entity._async_presence_changed(presence_event)
+    if sleep:
+        await asyncio.sleep(0.1)
     return ret
 
 
@@ -334,8 +418,18 @@ async def send_climate_change_event(
     new_hvac_action: HVACAction,
     old_hvac_action: HVACAction,
     date,
+    sleep=True,
 ):
     """Sending a new climate event simulating a change on the underlying climate state"""
+    _LOGGER.info(
+        "------- Testu: sending send_temperature_change_event, new_hvac_mode=%s old_hvac_mode=%s new_hvac_action=%s old_hvac_action=%s date=%s on %s",
+        new_hvac_mode,
+        old_hvac_mode,
+        new_hvac_action,
+        old_hvac_action,
+        date,
+        entity,
+    )
     climate_event = Event(
         EVENT_STATE_CHANGED,
         {
@@ -356,4 +450,14 @@ async def send_climate_change_event(
         },
     )
     ret = await entity._async_climate_changed(climate_event)
+    if sleep:
+        await asyncio.sleep(0.1)
     return ret
+
+
+def cancel_switchs_cycles(entity: VersatileThermostat):
+    """This method will cancel all running cycle on all underlying switch entity"""
+    if entity._is_over_climate:
+        return
+    for under in entity._underlyings:
+        under._cancel_cycle()

custom_components/versatile_thermostat/tests/conftest.py

@@ -55,9 +55,9 @@ def skip_notifications_fixture():
 def skip_turn_on_off_heater():
     """Skip turning on and off the heater"""
     with patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_heater_turn_on"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingEntity.turn_on"
     ), patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingEntity.turn_off"
     ):
         yield
 
@@ -87,6 +87,15 @@ def skip_control_heating_fixture():
         yield
 
 
+@pytest.fixture(name="skip_find_underlying_climate")
+def skip_find_underlying_climate_fixture():
+    """Skip the find_underlying_climate of VersatileThermostat"""
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate"
+    ):
+        yield
+
+
 @pytest.fixture(name="skip_hass_states_is_state")
 def skip_hass_states_is_state_fixture():
     """Skip the is_state in HomeAssistant"""

custom_components/versatile_thermostat/tests/const.py

@@ -9,6 +9,9 @@ from homeassistant.components.climate.const import (  # pylint: disable=unused-i
 from custom_components.versatile_thermostat.const import (
     CONF_NAME,
     CONF_HEATER,
+    CONF_HEATER_2,
+    CONF_HEATER_3,
+    CONF_HEATER_4,
     CONF_THERMOSTAT_CLIMATE,
     CONF_THERMOSTAT_SWITCH,
     CONF_THERMOSTAT_TYPE,
@@ -62,6 +65,21 @@ MOCK_TH_OVER_SWITCH_USER_CONFIG = {
     CONF_USE_PRESENCE_FEATURE: True,
 }
 
+MOCK_TH_OVER_4SWITCH_USER_CONFIG = {
+    CONF_NAME: "TheOver4SwitchMockName",
+    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: 8,
+    CONF_TEMP_MIN: 15,
+    CONF_TEMP_MAX: 30,
+    CONF_DEVICE_POWER: 1,
+    CONF_USE_WINDOW_FEATURE: True,
+    CONF_USE_MOTION_FEATURE: True,
+    CONF_USE_POWER_FEATURE: True,
+    CONF_USE_PRESENCE_FEATURE: True,
+}
+
 MOCK_TH_OVER_CLIMATE_USER_CONFIG = {
     CONF_NAME: "TheOverClimateMockName",
     CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
@@ -79,6 +97,14 @@ MOCK_TH_OVER_SWITCH_TYPE_CONFIG = {
     CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
 }
 
+MOCK_TH_OVER_4SWITCH_TYPE_CONFIG = {
+    CONF_HEATER: "switch.mock_4switch0",
+    CONF_HEATER_2: "switch.mock_4switch1",
+    CONF_HEATER_3: "switch.mock_4switch2",
+    CONF_HEATER_4: "switch.mock_4switch3",
+    CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+}
+
 MOCK_TH_OVER_SWITCH_TPI_CONFIG = {
     CONF_TPI_COEF_INT: 0.3,
     CONF_TPI_COEF_EXT: 0.1,

custom_components/versatile_thermostat/tests/test_binary_sensors.py

@@ -442,7 +442,7 @@ async def test_binary_sensors_over_climate_minimal(
 
     the_mock_underlying = MagicMockClimate()
     with patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=the_mock_underlying,
     ):
         entry = MockConfigEntry(

custom_components/versatile_thermostat/tests/test_bugs.py

@@ -0,0 +1,337 @@
+""" Test the Window management """
+from unittest.mock import patch
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from datetime import datetime, timedelta
+
+import logging
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+async def test_bug_56(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that in over_climate mode there is no error when underlying climate is not available"""
+
+    the_mock_underlying = MagicMockClimate()
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=None,  # dont find the underlying climate
+    ):
+        entry = MockConfigEntry(
+            domain=DOMAIN,
+            title="TheOverClimateMockName",
+            unique_id="uniqueId",
+            data={
+                CONF_NAME: "TheOverClimateMockName",
+                CONF_THERMOSTAT_TYPE: CONF_THERMOSTAT_CLIMATE,
+                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: False,
+                CONF_USE_PRESENCE_FEATURE: False,
+                CONF_CLIMATE: "climate.mock_climate",
+                CONF_MINIMAL_ACTIVATION_DELAY: 30,
+                CONF_SECURITY_DELAY_MIN: 5,
+                CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            },
+        )
+
+        entity: VersatileThermostat = await create_thermostat(
+            hass, entry, "climate.theoverclimatemockname"
+        )
+        assert entity
+        # cause the underlying climate was not found
+        assert entity.is_over_climate is True
+        assert entity.underlying_entity(0)._underlying_climate is None
+
+        # Should not failed
+        entity.update_custom_attributes()
+
+        # try to call _async_control_heating
+        try:
+            await entity._async_control_heating()
+            # an exception should be send
+            assert False
+        except UnknownEntity:
+            pass
+        except Exception:  # pylint: disable=broad-exception-caught
+            assert False
+
+    # This time the underlying will be found
+    with patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
+        return_value=the_mock_underlying,  # dont find the underlying climate
+    ):
+        # try to call _async_control_heating
+        try:
+            await entity._async_control_heating()
+        except UnknownEntity:
+            assert False
+        except Exception:  # pylint: disable=broad-exception-caught
+            assert False
+
+        # Should not failed
+        entity.update_custom_attributes()
+
+
+async def test_bug_63(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that it should be possible to set the security_default_on_percent to 0"""
+
+    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: 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.0,  # !! here
+            CONF_SECURITY_DEFAULT_ON_PERCENT: 0.0,  # !! here
+            CONF_DEVICE_POWER: 200,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+    assert entity._security_min_on_percent == 0
+    assert entity._security_default_on_percent == 0
+
+
+# Waiting for answer in https://github.com/jmcollin78/versatile_thermostat/issues/64
+# Repro case not evident
+async def test_bug_64(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that it should be possible to set the security_default_on_percent to 0"""
+
+    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: 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.5,
+            CONF_SECURITY_DEFAULT_ON_PERCENT: 0.1,  # !! here
+            CONF_DEVICE_POWER: 200,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theoverswitchmockname"
+    )
+    assert entity
+
+
+async def test_bug_66(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_turn_on_off_heater,
+    skip_send_event,
+):
+    """Test that it should be possible to open/close the window rapidly without side effect"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    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.5,
+            CONF_SECURITY_DEFAULT_ON_PERCENT: 0.1,  # !! here
+            CONF_DEVICE_POWER: 200,
+            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
+
+    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.window_state is None
+
+    # Open the window and let the thermostat shut down
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=True
+    ) as mock_condition, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ):
+        await send_temperature_change_event(entity, 15, now)
+        try_window_condition = await send_window_change_event(
+            entity, True, False, now, False
+        )
+
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        assert mock_send_event.call_count == 1
+        assert mock_heater_on.call_count == 1
+        assert mock_heater_off.call_count >= 1
+        assert mock_condition.call_count == 1
+
+        assert entity.window_state == STATE_ON
+
+    # Close the window but too shortly
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=False
+    ) as mock_condition, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ):
+        event_timestamp = now + timedelta(minutes=1)
+        try_window_condition = await send_window_change_event(
+            entity, False, True, event_timestamp
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        # window state should not have change
+        assert entity.window_state == STATE_ON
+
+    # Reopen immediatly with sufficient time
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=True
+    ) as mock_condition, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ):
+        try_window_condition = await send_window_change_event(
+            entity, True, False, event_timestamp
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        # still no change
+        assert entity.window_state == STATE_ON
+        assert entity.hvac_mode == HVACMode.OFF
+
+    # Close the window but with sufficient time this time
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "homeassistant.helpers.condition.state", return_value=True
+    ) as mock_condition, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ):
+        event_timestamp = now + timedelta(minutes=2)
+        try_window_condition = await send_window_change_event(
+            entity, False, True, event_timestamp
+        )
+        # simulate the call to try_window_condition
+        await try_window_condition(None)
+
+        # window state should be Off this time and old state should have been restored
+        assert entity.window_state == STATE_OFF
+        assert entity.hvac_mode is HVACMode.HEAT
+        assert entity.preset_mode is PRESET_BOOST

custom_components/versatile_thermostat/tests/test_config_flow.py

@@ -369,3 +369,92 @@ async def test_user_config_flow_window_auto_ko(
     assert result["errors"] == {
         "window_sensor_entity_id": "window_open_detection_method"
     }
+
+
+async def test_user_config_flow_over_4_switches(
+    hass: HomeAssistant, skip_hass_states_get, skip_control_heating
+):
+    """Test the config flow with 4 switchs thermostat_over_switch features"""
+
+    SOURCE_CONFIG = {  # pylint: disable=wildcard-import, invalid-name
+        CONF_NAME: "TheOver4SwitchMockName",
+        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,
+        CONF_DEVICE_POWER: 1,
+        CONF_USE_WINDOW_FEATURE: False,
+        CONF_USE_MOTION_FEATURE: False,
+        CONF_USE_POWER_FEATURE: False,
+        CONF_USE_PRESENCE_FEATURE: False,
+    }
+
+    TYPE_CONFIG = {  # pylint: disable=wildcard-import, invalid-name
+        CONF_HEATER: "switch.mock_switch1",
+        CONF_HEATER_2: "switch.mock_switch2",
+        CONF_HEATER_3: "switch.mock_switch3",
+        CONF_HEATER_4: "switch.mock_switch4",
+        CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+    }
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": SOURCE_USER}
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["step_id"] == SOURCE_USER
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=SOURCE_CONFIG,
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["step_id"] == "type"
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        user_input=TYPE_CONFIG,
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["step_id"] == "tpi"
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=MOCK_TH_OVER_SWITCH_TPI_CONFIG
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["step_id"] == "presets"
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=MOCK_PRESETS_CONFIG
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
+    assert result["step_id"] == "advanced"
+    assert result["errors"] == {}
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=MOCK_ADVANCED_CONFIG
+    )
+
+    assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
+    assert (
+        result["data"]
+        == SOURCE_CONFIG
+        | TYPE_CONFIG
+        | MOCK_TH_OVER_SWITCH_TPI_CONFIG
+        | MOCK_PRESETS_CONFIG
+        | MOCK_ADVANCED_CONFIG
+    )
+    assert result["result"]
+    assert result["result"].domain == DOMAIN
+    assert result["result"].version == 1
+    assert result["result"].title == "TheOver4SwitchMockName"
+    assert isinstance(result["result"], ConfigEntry)

custom_components/versatile_thermostat/tests/test_multiple_switch.py

@@ -0,0 +1,337 @@
+""" Test the Multiple switch management """
+import asyncio
+from unittest.mock import patch, call, ANY
+from .commons import *  # pylint: disable=wildcard-import, unused-wildcard-import
+from datetime import datetime, timedelta
+
+import logging
+
+logging.getLogger().setLevel(logging.DEBUG)
+
+
+async def test_one_switch_cycle(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_send_event,
+):
+    """Test that when multiple switch are configured the activation is distributed"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOver4SwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOver4SwitchMockName",
+            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: 8,
+            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: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch1",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theover4switchmockname"
+    )
+    assert entity
+    assert entity.is_over_climate is False
+
+    # start heating, in boost mode. We block the control_heating to avoid running a cycle
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_control_heating"
+    ):
+        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.window_state is None
+
+        event_timestamp = now - timedelta(minutes=4)
+        await send_temperature_change_event(entity, 15, event_timestamp)
+
+    # Checks that all heaters are off
+    with patch(
+        "homeassistant.core.StateMachine.is_state", return_value=False
+    ) as mock_is_state:
+        assert entity._is_device_active is False
+
+        # Should be call for the Switch
+        assert mock_is_state.call_count == 1
+
+    # Set temperature to a low level
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ) as mock_device_active, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.call_later",
+        return_value=None,
+    ) as mock_call_later:
+        await send_ext_temperature_change_event(entity, 5, event_timestamp)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+        # The first heater should be on but because call_later is mocked heater_on is not called
+        # assert mock_heater_on.call_count == 1
+        assert mock_heater_on.call_count == 0
+        # There is no check if active
+        assert mock_device_active.call_count == 0
+
+        # 4 calls dispatched along the cycle
+        assert mock_call_later.call_count == 1
+        mock_call_later.assert_has_calls(
+            [
+                call.call_later(hass, 0.0, ANY),
+            ]
+        )
+
+    # Set a temperature at middle level
+    event_timestamp = now - timedelta(minutes=4)
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ) as mock_device_active:
+        await send_temperature_change_event(entity, 18, event_timestamp)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+        # The first heater should be turned on but is already on but because above we mock call_later the heater is not on. But this time it will be really on
+        assert mock_heater_on.call_count == 1
+
+    # Set another temperature at middle level
+    event_timestamp = now - timedelta(minutes=3)
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ) as mock_device_active:
+        await send_temperature_change_event(entity, 18.1, event_timestamp)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+        # The heater is already on cycle. So we wait that the cycle ends and no heater action is done
+        assert mock_heater_on.call_count == 0
+        assert entity.underlying_entity(0)._should_relaunch_control_heating is True
+
+        # Simulate the relaunch
+        await entity.underlying_entity(0)._turn_on_later(None)
+        # wait restart
+        await asyncio.sleep(0.1)
+
+        assert mock_heater_on.call_count == 1
+        assert entity.underlying_entity(0)._should_relaunch_control_heating is False
+
+    # Simulate the end of heater on cycle
+    event_timestamp = now - timedelta(minutes=3)
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ) as mock_device_active:
+        await entity.underlying_entity(0)._turn_off_later(None)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 0
+        # The heater should be turned off this time
+        assert mock_heater_off.call_count == 1
+        assert entity.underlying_entity(0)._should_relaunch_control_heating is False
+
+    # Simulate the start of heater on cycle
+    event_timestamp = now - timedelta(minutes=3)
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=True,
+    ) as mock_device_active:
+        await entity.underlying_entity(0)._turn_on_later(None)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_on.call_count == 1
+        # The heater should be turned off this time
+        assert mock_heater_off.call_count == 0
+        assert entity.underlying_entity(0)._should_relaunch_control_heating is False
+
+
+async def test_multiple_switchs(
+    hass: HomeAssistant,
+    skip_hass_states_is_state,
+    skip_send_event,
+):
+    """Test that when multiple switch are configured the activation is distributed"""
+
+    tz = get_tz(hass)  # pylint: disable=invalid-name
+    now: datetime = datetime.now(tz=tz)
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOver4SwitchMockName",
+        unique_id="uniqueId",
+        data={
+            CONF_NAME: "TheOver4SwitchMockName",
+            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: 8,
+            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: False,
+            CONF_USE_PRESENCE_FEATURE: False,
+            CONF_HEATER: "switch.mock_switch1",
+            CONF_HEATER_2: "switch.mock_switch2",
+            CONF_HEATER_3: "switch.mock_switch3",
+            CONF_HEATER_4: "switch.mock_switch4",
+            CONF_MINIMAL_ACTIVATION_DELAY: 30,
+            CONF_SECURITY_DELAY_MIN: 5,
+            CONF_SECURITY_MIN_ON_PERCENT: 0.3,
+            CONF_PROP_FUNCTION: PROPORTIONAL_FUNCTION_TPI,
+            CONF_TPI_COEF_INT: 0.3,
+            CONF_TPI_COEF_EXT: 0.01,
+        },
+    )
+
+    entity: VersatileThermostat = await create_thermostat(
+        hass, entry, "climate.theover4switchmockname"
+    )
+    assert entity
+    assert entity.is_over_climate is False
+
+    # start heating, in boost mode. We block the control_heating to avoid running a cycle
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_control_heating"
+    ):
+        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.window_state is None
+
+        event_timestamp = now - timedelta(minutes=4)
+        await send_temperature_change_event(entity, 15, event_timestamp)
+
+    # Checks that all heaters are off
+    with patch(
+        "homeassistant.core.StateMachine.is_state", return_value=False
+    ) as mock_is_state:
+        assert entity._is_device_active is False
+
+        # Should be call for all Switch
+        assert mock_is_state.call_count == 4
+
+    # Set temperature to a low level
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ) as mock_device_active, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.call_later",
+        return_value=None,
+    ) as mock_call_later:
+        await send_ext_temperature_change_event(entity, 5, event_timestamp)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+        # The first heater should be on but because call_later is mocked heater_on is not called
+        # assert mock_heater_on.call_count == 1
+        assert mock_heater_on.call_count == 0
+        # There is no check if active
+        assert mock_device_active.call_count == 0
+
+        # 4 calls dispatched along the cycle
+        assert mock_call_later.call_count == 4
+        mock_call_later.assert_has_calls(
+            [
+                call.call_later(hass, 0.0, ANY),
+                call.call_later(hass, 120.0, ANY),
+                call.call_later(hass, 240.0, ANY),
+                call.call_later(hass, 360.0, ANY),
+            ]
+        )
+
+    # Set a temperature at middle level
+    event_timestamp = now - timedelta(minutes=4)
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
+    ) as mock_heater_on, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
+    ) as mock_heater_off, patch(
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.is_device_active",
+        return_value=False,
+    ) as mock_device_active:
+        await send_temperature_change_event(entity, 18, event_timestamp)
+
+        # No special event
+        assert mock_send_event.call_count == 0
+        assert mock_heater_off.call_count == 0
+
+        # The first heater should be turned on but is already on but because call_later is mocked, it is only turned on here
+        assert mock_heater_on.call_count == 1

custom_components/versatile_thermostat/tests/test_power.py

@@ -81,9 +81,9 @@ async def test_power_management_hvac_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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off:
         await send_max_power_change_event(entity, 149, datetime.now())
         assert await entity.check_overpowering() is True
@@ -160,9 +160,9 @@ async def test_power_management_hvac_on(hass: HomeAssistant, skip_hass_states_is
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off:
         await send_max_power_change_event(entity, 149, datetime.now())
         assert await entity.check_overpowering() is True
@@ -194,9 +194,9 @@ async def test_power_management_hvac_on(hass: HomeAssistant, skip_hass_states_is
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off:
         await send_power_change_event(entity, 48, datetime.now())
         assert await entity.check_overpowering() is False
@@ -278,13 +278,13 @@ async def test_power_management_energy_over_switch(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.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)
+        await send_temperature_change_event(entity, 15, datetime.now())
 
         assert entity.hvac_mode is HVACMode.HEAT
         assert entity.preset_mode is PRESET_BOOST
@@ -307,9 +307,9 @@ async def test_power_management_energy_over_switch(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off:
         await send_temperature_change_event(entity, 18, datetime.now())
         assert tpi_algo.on_percent == 0.3
@@ -329,9 +329,9 @@ async def test_power_management_energy_over_switch(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off:
         await send_temperature_change_event(entity, 20, datetime.now())
         assert tpi_algo.on_percent == 0.0
@@ -357,7 +357,7 @@ async def test_power_management_energy_over_climate(
 
     the_mock_underlying = MagicMockClimate()
     with patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=the_mock_underlying,
     ):
         entry = MockConfigEntry(

custom_components/versatile_thermostat/tests/test_security.py

@@ -87,7 +87,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on:
         event_timestamp = now - timedelta(minutes=6)
 
@@ -134,7 +134,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on:
         await entity.async_set_preset_mode(PRESET_BOOST)
 
@@ -149,7 +149,7 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on:
         event_timestamp = datetime.now()
 
@@ -185,4 +185,5 @@ async def test_security_feature(hass: HomeAssistant, skip_hass_states_is_state):
             any_order=True,
         )
 
-        assert mock_heater_on.call_count == 0
+        # Heater is now on
+        assert mock_heater_on.call_count == 1

custom_components/versatile_thermostat/tests/test_sensors.py

@@ -179,6 +179,8 @@ async def test_sensors_over_switch(
     )
     assert last_ext_temperature_sensor.device_class == SensorDeviceClass.TIMESTAMP
 
+    cancel_switchs_cycles(entity)
+
 
 async def test_sensors_over_climate(
     hass: HomeAssistant,
@@ -190,7 +192,7 @@ async def test_sensors_over_climate(
 
     the_mock_underlying = MagicMockClimate()
     with patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=the_mock_underlying,
     ):
         entry = MockConfigEntry(
@@ -324,7 +326,7 @@ async def test_sensors_over_climate_minimal(
 
     the_mock_underlying = MagicMockClimate()
     with patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=the_mock_underlying,
     ):
         entry = MockConfigEntry(

custom_components/versatile_thermostat/tests/test_start.py

@@ -91,7 +91,7 @@ async def test_over_climate_full_start(hass: HomeAssistant, skip_hass_states_is_
     with patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
     ) as mock_send_event, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat.find_underlying_climate",
+        "custom_components.versatile_thermostat.underlyings.UnderlyingClimate.find_underlying_climate",
         return_value=fake_underlying_climate,
     ) as mock_find_climate:
         entry.add_to_hass(hass)
@@ -139,7 +139,76 @@ async def test_over_climate_full_start(hass: HomeAssistant, skip_hass_states_is_
         )
 
         assert mock_find_climate.call_count == 1
-        assert mock_find_climate.mock_calls[0] == call("climate.mock_climate")
-        mock_find_climate.assert_has_calls(
-            [call.find_underlying_entity("climate.mock_climate")]
+        assert mock_find_climate.mock_calls[0] == call()
+        mock_find_climate.assert_has_calls([call.find_underlying_entity()])
+
+
+async def test_over_4switch_full_start(hass: HomeAssistant, skip_hass_states_is_state):
+    """Test the normal full start of a thermostat in thermostat_over_switch with 4 switches type"""
+
+    entry = MockConfigEntry(
+        domain=DOMAIN,
+        title="TheOver4SwitchMockName",
+        unique_id="uniqueId",
+        data=FULL_4SWITCH_CONFIG,
+    )
+
+    with patch(
+        "custom_components.versatile_thermostat.climate.VersatileThermostat.send_event"
+    ) as mock_send_event:
+        entry.add_to_hass(hass)
+        await hass.config_entries.async_setup(entry.entry_id)
+        assert entry.state is ConfigEntryState.LOADED
+
+        def find_my_entity(entity_id) -> ClimateEntity:
+            """Find my new entity"""
+            component: EntityComponent[ClimateEntity] = hass.data[CLIMATE_DOMAIN]
+            for entity in component.entities:
+                if entity.entity_id == entity_id:
+                    return entity
+
+        entity: VersatileThermostat = find_my_entity("climate.theover4switchmockname")
+
+        assert entity
+
+        assert entity.name == "TheOver4SwitchMockName"
+        assert entity._is_over_climate is False
+        assert entity.hvac_action is HVACAction.OFF
+        assert entity.hvac_mode is HVACMode.OFF
+        assert entity.target_temperature == entity.min_temp
+        assert entity.preset_modes == [
+            PRESET_NONE,
+            PRESET_ECO,
+            PRESET_COMFORT,
+            PRESET_BOOST,
+            PRESET_ACTIVITY,
+        ]
+        assert entity.preset_mode is PRESET_NONE
+        assert entity._security_state is False
+        assert entity._window_state is None
+        assert entity._motion_state is None
+        assert entity._presence_state is None
+        assert entity._prop_algorithm is not None
+
+        assert entity.nb_underlying_entities == 4
+
+        # Checks that we have the 4 UnderlyingEntity correctly configured
+        for idx in range(4):
+            under = entity.underlying_entity(idx)
+            assert under is not None
+            assert isinstance(under, UnderlyingSwitch)
+            assert under.entity_id == "switch.mock_4switch" + str(idx)
+            assert under.initial_delay_sec == 8 * 60 / 4 * idx
+
+        # should have been called with EventType.PRESET_EVENT and EventType.HVAC_MODE_EVENT
+        assert mock_send_event.call_count == 2
+
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.PRESET_EVENT, {"preset": PRESET_NONE}),
+                call.send_event(
+                    EventType.HVAC_MODE_EVENT,
+                    {"hvac_mode": HVACMode.OFF},
+                ),
+            ]
         )

custom_components/versatile_thermostat/tests/test_window.py

@@ -66,18 +66,16 @@ async def test_window_management_time_not_enough(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.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)
+        await send_window_change_event(entity, True, False, datetime.now())
+        # simulate the call to try_window_condition. No need due to 0 WINDOW_DELAY and sleep after event is sent
+        # await try_window_condition(None)
 
         assert mock_send_event.call_count == 0
         assert mock_heater_on.call_count == 1
@@ -152,9 +150,9 @@ async def test_window_management_time_enough(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "homeassistant.helpers.condition.state", return_value=True
     ) as mock_condition, patch(
@@ -162,11 +160,7 @@ async def test_window_management_time_enough(
         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)
+        await send_window_change_event(entity, True, False, datetime.now())
 
         assert mock_send_event.call_count == 1
         mock_send_event.assert_has_calls(
@@ -174,7 +168,7 @@ async def test_window_management_time_enough(
         )
         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_heater_off.call_count == 1
         assert mock_condition.call_count == 1
 
         assert entity.window_state == STATE_ON
@@ -259,9 +253,9 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,
@@ -281,9 +275,9 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,
@@ -316,9 +310,9 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         new_callable=PropertyMock,
@@ -341,9 +335,9 @@ async def test_window_auto_fast(hass: HomeAssistant, skip_hass_states_is_state):
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         new_callable=PropertyMock,
@@ -438,9 +432,9 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,
@@ -459,18 +453,32 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,
     ):
         event_timestamp = now - timedelta(minutes=3)
-        await send_temperature_change_event(entity, 18, event_timestamp)
+        await send_temperature_change_event(entity, 18, event_timestamp, sleep=False)
 
-        # The heater turns on
         assert mock_send_event.call_count == 2
+        # The heater turns off
+        mock_send_event.assert_has_calls(
+            [
+                call.send_event(EventType.HVAC_MODE_EVENT, {"hvac_mode": HVACMode.OFF}),
+                call.send_event(
+                    EventType.WINDOW_AUTO_EVENT,
+                    {
+                        "type": "start",
+                        "cause": "slope alert",
+                        "curve_slope": -1.0,
+                    },
+                ),
+            ],
+            any_order=True,
+        )
         assert mock_heater_on.call_count == 0
         assert mock_heater_off.call_count >= 1
         assert entity.last_temperature_slope == -1
@@ -483,9 +491,9 @@ async def test_window_auto_auto_stop(hass: HomeAssistant, skip_hass_states_is_st
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=False,
@@ -564,9 +572,9 @@ async def test_window_auto_no_on_percent(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,
@@ -586,9 +594,9 @@ async def test_window_auto_no_on_percent(
     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"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_on"
     ) as mock_heater_on, patch(
-        "custom_components.versatile_thermostat.climate.VersatileThermostat._async_underlying_entity_turn_off"
+        "custom_components.versatile_thermostat.underlyings.UnderlyingSwitch.turn_off"
     ) as mock_heater_off, patch(
         "custom_components.versatile_thermostat.climate.VersatileThermostat._is_device_active",
         return_value=True,

custom_components/versatile_thermostat/translations/en.json

@@ -22,12 +22,23 @@
         }
       },
       "type": {
-        "title": "Linked entity",
-        "description": "Linked entity attributes",
+        "title": "Linked entities",
+        "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "Heater entity id",
+          "heater_entity_id": "Heater switch",
+          "heater_entity2_id": "2nd Heater switch",
+          "heater_entity3_id": "3rd Heater switch",
+          "heater_entity4_id": "4th Heater switch",
+          "proportional_function": "Algorithm",
+          "climate_entity_id": "Underlying thermostat"
+        },
+        "data_description": {
+          "heater_entity_id": "Mandatory heater entity id",
+          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
+          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
+          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying thermostat entity id"
+          "climate_entity_id": "Underlying climate entity id"
         }
       },
       "tpi": {
@@ -142,12 +153,23 @@
         }
       },
       "type": {
-        "title": "Linked entity",
-        "description": "Linked entity attributes",
+        "title": "Linked entities",
+        "description": "Linked entities attributes",
         "data": {
-          "heater_entity_id": "Heater entity id",
+          "heater_entity_id": "Heater switch",
+          "heater_entity2_id": "2nd Heater switch",
+          "heater_entity3_id": "3rd Heater switch",
+          "heater_entity4_id": "4th Heater switch",
+          "proportional_function": "Algorithm",
+          "climate_entity_id": "Underlying thermostat"
+        },
+        "data_description": {
+          "heater_entity_id": "Mandatory heater entity id",
+          "heater_entity2_id": "Optional 2nd Heater entity id. Leave empty if not used",
+          "heater_entity3_id": "Optional 3rd Heater entity id. Leave empty if not used",
+          "heater_entity4_id": "Optional 4th Heater entity id. Leave empty if not used",
           "proportional_function": "Algorithm to use (TPI is the only one for now)",
-          "climate_entity_id": "Underlying thermostat entity id"
+          "climate_entity_id": "Underlying climate entity id"
         }
       },
       "tpi": {

custom_components/versatile_thermostat/translations/fr.json

@@ -21,12 +21,23 @@
         }
       },
       "type": {
-        "title": "Entité liée",
-        "description": "Attributs de l'entité liée",
+        "title": "Entité(s) liée(s)",
+        "description": "Attributs de(s) l'entité(s) liée(s)",
         "data": {
-          "heater_entity_id": "Radiateur entity id",
+          "heater_entity_id": "1er radiateur",
+          "heater_entity2_id": "2ème radiateur",
+          "heater_entity3_id": "3ème radiateur",
+          "heater_entity4_id": "4ème radiateur",
+          "proportional_function": "Algorithme",
+          "climate_entity_id": "Thermostat sous-jacent"
+        },
+        "data_description": {
+          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
+          "heater_entity2_id": "Optionnel entity id du 2ème radiateur",
+          "heater_entity3_id": "Optionnel entity id du 3ème radiateur",
+          "heater_entity4_id": "Optionnel entity id du 4ème radiateur",
           "proportional_function": "Algorithme à utiliser (Seul TPI est disponible pour l'instant)",
-          "climate_entity_id": "Thermostat sous-jacent entity id"
+          "climate_entity_id": "Entity id du thermostat sous-jacent"
         }
       },
       "tpi": {
@@ -142,12 +153,23 @@
         }
       },
       "type": {
-        "title": "Entité liée",
-        "description": "Attributs de l'entité liée",
+        "title": "Entité(s) liée(s)",
+        "description": "Attributs de(s) l'entité(s) liée(s)",
         "data": {
-          "heater_entity_id": "Radiateur entity id",
+          "heater_entity_id": "1er radiateur",
+          "heater_entity2_id": "2ème radiateur",
+          "heater_entity3_id": "3ème radiateur",
+          "heater_entity4_id": "4ème radiateur",
+          "proportional_function": "Algorithme",
+          "climate_entity_id": "Thermostat sous-jacent"
+        },
+        "data_description": {
+          "heater_entity_id": "Entity id du 1er radiateur obligatoire",
+          "heater_entity2_id": "Optionnel entity id du 2ème radiateur",
+          "heater_entity3_id": "Optionnel entity id du 3ème radiateur",
+          "heater_entity4_id": "Optionnel entity id du 4ème radiateur",
           "proportional_function": "Algorithme à utiliser (Seul TPI est disponible pour l'instant)",
-          "climate_entity_id": "Thermostat sous-jacent entity id"
+          "climate_entity_id": "Entity id du thermostat sous-jacent"
         }
       },
       "tpi": {

custom_components/versatile_thermostat/underlyings.py

@@ -0,0 +1,578 @@
+""" Underlying entities classes """
+import logging
+from typing import Any
+
+from homeassistant.const import ATTR_ENTITY_ID, STATE_ON, UnitOfTemperature
+
+from homeassistant.exceptions import ServiceNotFound
+
+from homeassistant.backports.enum import StrEnum
+from homeassistant.core import HomeAssistant, DOMAIN as HA_DOMAIN, CALLBACK_TYPE
+from homeassistant.components.climate import (
+    ClimateEntity,
+    ClimateEntityFeature,
+    DOMAIN as CLIMATE_DOMAIN,
+    HVACMode,
+    HVACAction,
+    SERVICE_SET_HVAC_MODE,
+    SERVICE_SET_FAN_MODE,
+    SERVICE_SET_HUMIDITY,
+    SERVICE_SET_SWING_MODE,
+    SERVICE_TURN_OFF,
+    SERVICE_TURN_ON,
+    SERVICE_SET_TEMPERATURE,
+)
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.event import async_call_later
+
+from .const import UnknownEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+# remove this
+# _LOGGER.setLevel(logging.DEBUG)
+
+
+class UnderlyingEntityType(StrEnum):
+    """All underlying device type"""
+
+    # A switch
+    SWITCH = "switch"
+
+    # a climate
+    CLIMATE = "climate"
+
+
+class UnderlyingEntity:
+    """Represent a underlying device which could be a switch or a climate"""
+
+    _hass: HomeAssistant
+    # Cannot import VersatileThermostat due to circular reference
+    _thermostat: Any
+    _entity_id: str
+    _type: UnderlyingEntityType
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        thermostat: Any,
+        entity_type: UnderlyingEntityType,
+        entity_id: str,
+    ) -> None:
+        """Initialize the underlying entity"""
+        self._hass = hass
+        self._thermostat = thermostat
+        self._type = entity_type
+        self._entity_id = entity_id
+
+    def __str__(self):
+        return str(self._thermostat) + "-" + self._entity_id
+
+    @property
+    def entity_id(self):
+        """The entiy id represented by this class"""
+        return self._entity_id
+
+    @property
+    def entity_type(self) -> UnderlyingEntityType:
+        """The entity type represented by this class"""
+        return self._type
+
+    @property
+    def is_initialized(self) -> bool:
+        """True if the underlying is initialized"""
+        return True
+
+    def startup(self):
+        """Startup the Entity"""
+        return
+
+    async def set_hvac_mode(self, hvac_mode: HVACMode):
+        """Set the HVACmode"""
+        return
+
+    @property
+    def is_device_active(self) -> bool | None:
+        """If the toggleable device is currently active."""
+        return None
+
+    async def turn_off(self):
+        """Turn heater toggleable device off."""
+        _LOGGER.debug("%s - Stopping underlying entity %s", self, self._entity_id)
+        # This may fails if called after shutdown
+        try:
+            data = {ATTR_ENTITY_ID: self._entity_id}
+            await self._hass.services.async_call(
+                HA_DOMAIN,
+                SERVICE_TURN_OFF,
+                data,
+            )
+        except ServiceNotFound as err:
+            _LOGGER.error(err)
+
+    async def turn_on(self):
+        """Turn heater toggleable device on."""
+        _LOGGER.debug("%s - Starting underlying entity %s", self, self._entity_id)
+        try:
+            data = {ATTR_ENTITY_ID: self._entity_id}
+            await self._hass.services.async_call(
+                HA_DOMAIN,
+                SERVICE_TURN_ON,
+                data,
+            )
+        except ServiceNotFound as err:
+            _LOGGER.error(err)
+
+    async def set_temperature(self, temperature, max_temp, min_temp):
+        """Set the target temperature"""
+        return
+
+    async def remove_entity(self):
+        """Remove the underlying entity"""
+        return
+
+    # override to be able to mock the call
+    def call_later(
+        self, hass: HomeAssistant, delay_sec: int, called_method
+    ) -> CALLBACK_TYPE:
+        """Call the method after a delay"""
+        return async_call_later(hass, delay_sec, called_method)
+
+
+class UnderlyingSwitch(UnderlyingEntity):
+    """Represent a underlying switch"""
+
+    _initialDelaySec: int
+    _on_time_sec: int
+    _off_time_sec: int
+    _hvac_mode: HVACMode
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        thermostat: Any,
+        switch_entity_id: str,
+        initial_delay_sec: int,
+    ) -> None:
+        """Initialize the underlying switch"""
+
+        super().__init__(
+            hass=hass,
+            thermostat=thermostat,
+            entity_type=UnderlyingEntityType.SWITCH,
+            entity_id=switch_entity_id,
+        )
+        self._initial_delay_sec = initial_delay_sec
+        self._async_cancel_cycle = None
+        self._should_relaunch_control_heating = False
+        self._on_time_sec = 0
+        self._off_time_sec = 0
+
+    @property
+    def initial_delay_sec(self):
+        """The initial delay for this class"""
+        return self._initial_delay_sec
+
+    async def set_hvac_mode(self, hvac_mode: HVACMode):
+        """Set the HVACmode"""
+        if hvac_mode == HVACMode.OFF:
+            if self.is_device_active:
+                await self.turn_off()
+        return
+
+    @property
+    def is_device_active(self):
+        """If the toggleable device is currently active."""
+        return self._hass.states.is_state(self._entity_id, STATE_ON)
+
+    async def check_initial_state(self, hvac_mode: HVACMode):
+        """Prevent the heater to be on but thermostat is off"""
+        if hvac_mode == HVACMode.OFF and self.is_device_active:
+            _LOGGER.warning(
+                "%s - The hvac mode is OFF, but the switch device is ON. Turning off device %s",
+                self,
+                self._entity_id,
+            )
+            await self.turn_off()
+
+    async def start_cycle(
+        self,
+        hvac_mode: HVACMode,
+        on_time_sec: int,
+        off_time_sec: int,
+        force=False,
+    ):
+        """Starting cycle for switch"""
+        _LOGGER.debug(
+            "%s - Starting new cycle hvac_mode=%s on_time_sec=%d off_time_sec=%d force=%s",
+            self,
+            hvac_mode,
+            on_time_sec,
+            off_time_sec,
+            force,
+        )
+
+        self._on_time_sec = on_time_sec
+        self._off_time_sec = off_time_sec
+        self._hvac_mode = hvac_mode
+
+        # Cancel eventual previous cycle if any
+        if self._async_cancel_cycle is not None:
+            if force:
+                _LOGGER.debug("%s - we force a new cycle", self)
+                await self._cancel_cycle()
+            else:
+                _LOGGER.debug(
+                    "%s - A previous cycle is alredy running and no force -> waits for its end",
+                    self,
+                )
+                self._should_relaunch_control_heating = True
+                _LOGGER.debug("%s - End of cycle (2)", self)
+                return
+
+        # If we should heat, starts the cycle with delay
+        if self._hvac_mode == HVACMode.HEAT and on_time_sec > 0:
+            # Starts the cycle after the initial delay
+            self._async_cancel_cycle = self.call_later(
+                self._hass, self._initial_delay_sec, self._turn_on_later
+            )
+            _LOGGER.debug("%s - _async_cancel_cycle=%s", self, self._async_cancel_cycle)
+
+        # if we not heat but device is active
+        elif self.is_device_active:
+            _LOGGER.info(
+                "%s - stop heating (2) for %d min %d sec",
+                self,
+                off_time_sec // 60,
+                off_time_sec % 60,
+            )
+            await self.turn_off()
+        else:
+            _LOGGER.debug("%s - nothing to do", self)
+
+    async def _cancel_cycle(self):
+        """Cancel the cycle"""
+        if self._async_cancel_cycle:
+            self._async_cancel_cycle()
+            self._async_cancel_cycle = None
+            _LOGGER.debug("%s - Stopping cycle during calculation", self)
+
+    async def _turn_on_later(self, _):
+        """Turn the heater on after a delay"""
+        _LOGGER.debug(
+            "%s - calling turn_on_later hvac_mode=%s, should_relaunch_later=%s off_time_sec=%d",
+            self,
+            self._hvac_mode,
+            self._should_relaunch_control_heating,
+            self._on_time_sec,
+        )
+
+        await self._cancel_cycle()
+
+        if self._hvac_mode == HVACMode.OFF:
+            _LOGGER.debug("%s - End of cycle (HVAC_MODE_OFF - 2)", self)
+            if self.is_device_active:
+                await self.turn_off()
+            return
+
+        if await self._thermostat.check_overpowering():
+            _LOGGER.debug("%s - End of cycle (3)", self)
+            return
+        # Security mode could have change the on_time percent
+        await self._thermostat.check_security()
+        time = self._on_time_sec
+
+        action_label = "start"
+        # if self._should_relaunch_control_heating:
+        #    _LOGGER.debug("Don't %s cause a cycle have to be relaunch", action_label)
+        #    self._should_relaunch_control_heating = False
+        #    # self.hass.create_task(self._async_control_heating())
+        #    await self.start_cycle(
+        #        self._hvac_mode, self._on_time_sec, self._off_time_sec
+        #    )
+        #    _LOGGER.debug("%s - End of cycle (3)", self)
+        #    return
+
+        if time > 0:
+            _LOGGER.info(
+                "%s - %s heating for %d min %d sec",
+                self,
+                action_label,
+                time // 60,
+                time % 60,
+            )
+            await self.turn_on()
+        else:
+            _LOGGER.debug("%s - No action on heater cause duration is 0", self)
+        self._async_cancel_cycle = self.call_later(
+            self._hass,
+            time,
+            self._turn_off_later,
+        )
+
+    async def _turn_off_later(self, _):
+        """Turn the heater off and call the next cycle after the delay"""
+        _LOGGER.debug(
+            "%s - calling turn_off_later hvac_mode=%s, should_relaunch_later=%s off_time_sec=%d",
+            self,
+            self._hvac_mode,
+            self._should_relaunch_control_heating,
+            self._off_time_sec,
+        )
+        await self._cancel_cycle()
+
+        if self._hvac_mode == HVACMode.OFF:
+            _LOGGER.debug("%s - End of cycle (HVAC_MODE_OFF - 2)", self)
+            if self.is_device_active:
+                await self.turn_off()
+            return
+
+        action_label = "stop"
+        # if self._should_relaunch_control_heating:
+        #    _LOGGER.debug("Don't %s cause a cycle have to be relaunch", action_label)
+        #    self._should_relaunch_control_heating = False
+        #    # self.hass.create_task(self._async_control_heating())
+        #    await self.start_cycle(
+        #        self._hvac_mode, self._on_time_sec, self._off_time_sec
+        #    )
+        #    _LOGGER.debug("%s - End of cycle (3)", self)
+        #    return
+
+        time = self._off_time_sec
+
+        if time > 0:
+            _LOGGER.info(
+                "%s - %s heating for %d min %d sec",
+                self,
+                action_label,
+                time // 60,
+                time % 60,
+            )
+            await self.turn_off()
+        else:
+            _LOGGER.debug("%s - No action on heater cause duration is 0", self)
+        self._async_cancel_cycle = self.call_later(
+            self._hass,
+            time,
+            self._turn_on_later,
+        )
+
+        # increment energy at the end of the cycle
+        self._thermostat.incremente_energy()
+
+    async def remove_entity(self):
+        """Remove the entity"""
+        await self._cancel_cycle()
+
+
+class UnderlyingClimate(UnderlyingEntity):
+    """Represent a underlying climate"""
+
+    _underlying_climate: ClimateEntity
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        thermostat: Any,
+        climate_entity_id: str,
+    ) -> None:
+        """Initialize the underlying climate"""
+
+        super().__init__(
+            hass=hass,
+            thermostat=thermostat,
+            entity_type=UnderlyingEntityType.CLIMATE,
+            entity_id=climate_entity_id,
+        )
+        self._underlying_climate = None
+
+    def find_underlying_climate(self) -> ClimateEntity:
+        """Find the underlying climate entity"""
+        component: EntityComponent[ClimateEntity] = self._hass.data[CLIMATE_DOMAIN]
+        for entity in component.entities:
+            if self.entity_id == entity.entity_id:
+                return entity
+        return None
+
+    def startup(self):
+        """Startup the Entity"""
+        # Get the underlying climate
+        self._underlying_climate = self.find_underlying_climate()
+        if self._underlying_climate:
+            _LOGGER.info(
+                "%s - The underlying climate entity: %s have been succesfully found",
+                self,
+                self._underlying_climate,
+            )
+        else:
+            _LOGGER.error(
+                "%s - Cannot find the underlying climate entity: %s. Thermostat will not be operational",
+                self,
+                self.entity_id,
+            )
+            # #56 keep the over_climate and try periodically to find the underlying climate
+            # self._is_over_climate = False
+            raise UnknownEntity(f"Underlying entity {self.entity_id} not found")
+        return
+
+    @property
+    def is_initialized(self) -> bool:
+        """True if the underlying climate was found"""
+        return self._underlying_climate is not None
+
+    async def set_hvac_mode(self, hvac_mode: HVACMode):
+        """Set the HVACmode of the underlying climate"""
+        if not self.is_initialized:
+            return
+
+        data = {ATTR_ENTITY_ID: self._entity_id, "hvac_mode": hvac_mode}
+        await self._hass.services.async_call(
+            CLIMATE_DOMAIN,
+            SERVICE_SET_HVAC_MODE,
+            data,
+        )
+
+    @property
+    def is_device_active(self):
+        """If the toggleable device is currently active."""
+        if self.is_initialized:
+            return self._underlying_climate.hvac_action not in [
+                HVACAction.IDLE,
+                HVACAction.OFF,
+            ]
+        else:
+            return None
+
+    async def set_fan_mode(self, fan_mode):
+        """Set new target fan mode."""
+        if not self.is_initialized:
+            return
+        data = {
+            ATTR_ENTITY_ID: self._entity_id,
+            "fan_mode": fan_mode,
+        }
+
+        await self._hass.services.async_call(
+            CLIMATE_DOMAIN,
+            SERVICE_SET_FAN_MODE,
+            data,
+        )
+
+    async def set_humidity(self, humidity: int):
+        """Set new target humidity."""
+        _LOGGER.info("%s - Set fan mode: %s", self, humidity)
+        if not self.is_initialized:
+            return
+        data = {
+            ATTR_ENTITY_ID: self._entity_id,
+            "humidity": humidity,
+        }
+
+        await self._hass.services.async_call(
+            CLIMATE_DOMAIN,
+            SERVICE_SET_HUMIDITY,
+            data,
+        )
+
+    async def set_swing_mode(self, swing_mode):
+        """Set new target swing operation."""
+        _LOGGER.info("%s - Set fan mode: %s", self, swing_mode)
+        if not self.is_initialized:
+            return
+        data = {
+            ATTR_ENTITY_ID: self._entity_id,
+            "swing_mode": swing_mode,
+        }
+
+        await self._hass.services.async_call(
+            CLIMATE_DOMAIN,
+            SERVICE_SET_SWING_MODE,
+            data,
+        )
+
+    async def set_temperature(self, temperature, max_temp, min_temp):
+        """Set the target temperature"""
+        if not self.is_initialized:
+            return
+        data = {
+            ATTR_ENTITY_ID: self._entity_id,
+            "temperature": temperature,
+            "target_temp_high": max_temp,
+            "target_temp_low": min_temp,
+        }
+
+        await self._hass.services.async_call(
+            CLIMATE_DOMAIN,
+            SERVICE_SET_TEMPERATURE,
+            data,
+        )
+
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Get the hvac action of the underlying"""
+        if not self.is_initialized:
+            return None
+        return self._underlying_climate.hvac_action
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Get the hvac mode of the underlying"""
+        if not self.is_initialized:
+            return None
+        return self._underlying_climate.hvac_mode
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Get the fan_mode of the underlying"""
+        if not self.is_initialized:
+            return None
+        return self._underlying_climate.fan_mode
+
+    @property
+    def swing_mode(self) -> str | None:
+        """Get the swing_mode of the underlying"""
+        if not self.is_initialized:
+            return None
+        return self._underlying_climate.swing_mode
+
+    @property
+    def supported_features(self) -> ClimateEntityFeature:
+        """Get the supported features of the climate"""
+        if not self.is_initialized:
+            return ClimateEntityFeature.TARGET_TEMPERATURE
+        return self._underlying_climate.supported_features
+
+    @property
+    def hvac_modes(self) -> list[HVACMode]:
+        """Get the hvac_modes"""
+        if not self.is_initialized:
+            return []
+        return self._underlying_climate.hvac_modes
+
+    @property
+    def fan_modes(self) -> list[str]:
+        """Get the fan_modes"""
+        if not self.is_initialized:
+            return []
+        return self._underlying_climate.fan_modes
+
+    @property
+    def swing_modes(self) -> list[str]:
+        """Get the swing_modes"""
+        if not self.is_initialized:
+            return []
+        return self._underlying_climate.swing_modes
+
+    @property
+    def temperature_unit(self) -> str:
+        """Get the temperature_unit"""
+        if not self.is_initialized:
+            return UnitOfTemperature.CELSIUS
+        return self._underlying_climate.temperature_unit
+
+    @property
+    def target_temperature_step(self) -> str:
+        """Get the target_temperature_step"""
+        if not self.is_initialized:
+            return 1
+        return self._underlying_climate.target_temperature_step