diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index d8d7284d..ac289eb2 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -9,7 +9,8 @@ PRERELEASE_NOTE
 ## :pencil2: Features
 
 - Allow to pass parameters to predefined actions. You can check the parameters for each predefined action, and how to pass parameters in [here](https://xaviml.github.io/controllerx/advanced/predefined-actions). [ #78 ]
-- Support for Light Group integration. To know how entity groups work, read [here](https://xaviml.github.io/controllerx/advanced/entity-groups)
+- Support for Light Group integration. To know how entity groups work, read [here](https://xaviml.github.io/controllerx/advanced/entity-groups) [ #330 ]
+- Add option to read `unique_id` attribute for deCONZ integration. Read more about it [here](https://xaviml.github.io/controllerx/others/integrations#deconz) [ #333 ]
 
 <!--
 ## :hammer: Fixes
diff --git a/apps/controllerx/cx_core/integration/deconz.py b/apps/controllerx/cx_core/integration/deconz.py
index 283faa9d..95520939 100644
--- a/apps/controllerx/cx_core/integration/deconz.py
+++ b/apps/controllerx/cx_core/integration/deconz.py
@@ -4,6 +4,9 @@
 from cx_const import DefaultActionsMapping  # type:ignore
 from cx_core.integration import EventData, Integration
 
+LISTENS_TO_ID = "id"
+LISTENS_TO_UNIQUE_ID = "unique_id"
+
 
 class DeCONZIntegration(Integration):
     name = "deconz"
@@ -12,8 +15,16 @@ def get_default_actions_mapping(self) -> Optional[DefaultActionsMapping]:
         return self.controller.get_deconz_actions_mapping()
 
     async def listen_changes(self, controller_id: str) -> None:
+        listens_to = self.kwargs.get("listen_to", LISTENS_TO_ID)
+        if listens_to not in (LISTENS_TO_ID, LISTENS_TO_UNIQUE_ID):
+            raise ValueError(
+                "`listens_to` for deCONZ integration should either be `id` or `unique_id`"
+            )
         await Hass.listen_event(
-            self.controller, self.event_callback, "deconz_event", id=controller_id
+            self.controller,
+            self.event_callback,
+            "deconz_event",
+            **{listens_to: controller_id}
         )
 
     async def event_callback(
diff --git a/apps/controllerx/cx_core/integration/lutron_caseta.py b/apps/controllerx/cx_core/integration/lutron_caseta.py
index 7015d073..3a81cb20 100644
--- a/apps/controllerx/cx_core/integration/lutron_caseta.py
+++ b/apps/controllerx/cx_core/integration/lutron_caseta.py
@@ -14,12 +14,14 @@ def get_default_actions_mapping(self) -> Optional[DefaultActionsMapping]:
     async def listen_changes(self, controller_id: str) -> None:
         await Hass.listen_event(
             self.controller,
-            self.callback,
+            self.event_callback,
             "lutron_caseta_button_event",
             serial=controller_id,
         )
 
-    async def callback(self, event_name: str, data: EventData, kwargs: dict) -> None:
+    async def event_callback(
+        self, event_name: str, data: EventData, kwargs: dict
+    ) -> None:
         button = data["button_number"]
         action_type = data["action"]
         action = f"button_{button}_{action_type}"
diff --git a/apps/controllerx/cx_core/integration/zha.py b/apps/controllerx/cx_core/integration/zha.py
index 960bbc88..8a40e1bb 100644
--- a/apps/controllerx/cx_core/integration/zha.py
+++ b/apps/controllerx/cx_core/integration/zha.py
@@ -13,7 +13,7 @@ def get_default_actions_mapping(self) -> Optional[DefaultActionsMapping]:
 
     async def listen_changes(self, controller_id: str) -> None:
         await Hass.listen_event(
-            self.controller, self.callback, "zha_event", device_ieee=controller_id
+            self.controller, self.event_callback, "zha_event", device_ieee=controller_id
         )
 
     def get_action(self, data: EventData) -> str:
@@ -28,7 +28,9 @@ def get_action(self, data: EventData) -> str:
                 action += "_" + "_".join(args)
         return action
 
-    async def callback(self, event_name: str, data: EventData, kwargs: dict) -> None:
+    async def event_callback(
+        self, event_name: str, data: EventData, kwargs: dict
+    ) -> None:
         action = self.controller.get_zha_action(data)
         if action is None:
             # If there is no action extracted from the controller then
diff --git a/docs/others/integrations.md b/docs/others/integrations.md
index c17716ee..fc1e0d94 100644
--- a/docs/others/integrations.md
+++ b/docs/others/integrations.md
@@ -41,7 +41,7 @@ Three things to clarify when using the `z2m` integration listening to MQTT:
 
 #### deCONZ
 
-This integration(**`deconz`**) listens to `deconz_event` events and actions gets fired by default with the `event` attribute from the `data` object. However, you can change the attribute to listen to by adding a `type` attribute. This is an example
+This integration(**`deconz`**) listens to `deconz_event` events and actions gets fired by default with the `event` attribute from the `data` object. However, you can change the attribute to listen to by adding a `type` attribute. In addition, you can select which attribute to listen to (`id` or `unique_id`) with `listen_to`. This is an example:
 
 ```yaml
 example_app:
@@ -50,7 +50,8 @@ example_app:
   controller: magic_cube
   integration:
     name: deconz
-    type: gesture
+    listen_to: unique_id # defaults to `id`
+    type: gesture # defaults to `event`
   light: light.example_light
 ```
 
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 59f42c5d..0c640149 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -71,7 +71,7 @@ def get_classes(file_, package_, class_, instantiate=False):
 
 
 @contextmanager
-def wrap_exetuction(
+def wrap_execution(
     *, error_expected: bool, exception=Exception
 ) -> Generator[Optional[ExceptionInfo], None, None]:
     if error_expected:
diff --git a/tests/unit_tests/cx_core/action-types/predefined_action_type_test.py b/tests/unit_tests/cx_core/action-types/predefined_action_type_test.py
index 561746ab..06797f6d 100644
--- a/tests/unit_tests/cx_core/action-types/predefined_action_type_test.py
+++ b/tests/unit_tests/cx_core/action-types/predefined_action_type_test.py
@@ -5,7 +5,7 @@
 from cx_core.action_type.predefined_action_type import _get_action, _get_arguments
 from cx_core.integration import EventData
 
-from tests.test_utils import fake_fn, wrap_exetuction
+from tests.test_utils import fake_fn, wrap_execution
 
 
 @pytest.mark.parametrize(
@@ -92,7 +92,7 @@ def test_get_arguments_general(
     async def test_fn(a: str, b: int = 2):
         pass
 
-    with wrap_exetuction(error_expected=expected is None, exception=ValueError):
+    with wrap_execution(error_expected=expected is None, exception=ValueError):
         output = _get_arguments(test_fn, action_args, user_args, None)
 
     if expected is not None:
@@ -131,7 +131,7 @@ def test_get_arguments_with_extra(
     async def test_fn(a: str, b: int, extra: Optional[EventData] = None):
         pass
 
-    with wrap_exetuction(error_expected=expected is None, exception=ValueError):
+    with wrap_execution(error_expected=expected is None, exception=ValueError):
         output = _get_arguments(test_fn, action_args, user_args, extra)
 
     if expected is not None:
diff --git a/tests/unit_tests/cx_core/color_helper_test.py b/tests/unit_tests/cx_core/color_helper_test.py
index be200663..e71fd71c 100644
--- a/tests/unit_tests/cx_core/color_helper_test.py
+++ b/tests/unit_tests/cx_core/color_helper_test.py
@@ -1,7 +1,7 @@
 import pytest
 from cx_core.color_helper import Colors, get_color_wheel
 
-from tests.test_utils import wrap_exetuction
+from tests.test_utils import wrap_execution
 
 
 @pytest.mark.parametrize(
@@ -14,5 +14,5 @@
     ],
 )
 def test_get_color_wheel(colors: Colors, error_expected: bool):
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         colors = get_color_wheel(colors)
diff --git a/tests/unit_tests/cx_core/controller_test.py b/tests/unit_tests/cx_core/controller_test.py
index e92c5b5a..5085e3d9 100644
--- a/tests/unit_tests/cx_core/controller_test.py
+++ b/tests/unit_tests/cx_core/controller_test.py
@@ -10,7 +10,7 @@
 from cx_core.controller import Controller, action
 from pytest_mock.plugin import MockerFixture
 
-from tests.test_utils import IntegrationMock, fake_fn, wrap_exetuction
+from tests.test_utils import IntegrationMock, fake_fn, wrap_execution
 
 INTEGRATION_TEST_NAME = "test"
 CONTROLLER_NAME = "test_controller"
@@ -164,7 +164,7 @@ async def test_initialize(
     )
 
     # SUT
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         await sut_before_init.initialize()
 
     # Checks
@@ -214,7 +214,7 @@ async def test_merge_mapping(
     )
 
     # SUT
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         await sut_before_init.initialize()
 
     # Checks
@@ -332,7 +332,7 @@ def test_get_multiple_click_actions(
 def test_get_option(
     sut: Controller, option: str, options: List[str], error_expected: bool
 ):
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         sut.get_option(option, options)
 
 
@@ -361,7 +361,7 @@ def test_get_integration(
 ):
     get_integrations_spy = mocker.spy(integration_module, "get_integrations")
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         integration = fake_controller.get_integration(integration_input)
 
     if not error_expected:
diff --git a/tests/unit_tests/cx_core/integration/deconz_test.py b/tests/unit_tests/cx_core/integration/deconz_test.py
index 6c26c0a0..5eefeb6a 100644
--- a/tests/unit_tests/cx_core/integration/deconz_test.py
+++ b/tests/unit_tests/cx_core/integration/deconz_test.py
@@ -1,10 +1,13 @@
 from typing import Dict, Optional
 
 import pytest
+from appdaemon.plugins.hass.hassapi import Hass
 from cx_core.controller import Controller
 from cx_core.integration.deconz import DeCONZIntegration
 from pytest_mock.plugin import MockerFixture
 
+from tests.test_utils import wrap_execution
+
 
 @pytest.mark.parametrize(
     "data, type, expected",
@@ -36,3 +39,38 @@ async def test_callback(
     deconz_integration = DeCONZIntegration(fake_controller, kwargs)
     await deconz_integration.event_callback("test", data, {})
     handle_action_patch.assert_called_once_with(expected, extra=data)
+
+
+@pytest.mark.parametrize(
+    "listen_to, expected_id",
+    [
+        ("id", "id"),
+        ("unique_id", "unique_id"),
+        (None, "id"),
+        ("fake", None),
+    ],
+)
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+    listen_to: Optional[str],
+    expected_id: Optional[str],
+):
+    kwargs = {}
+    if listen_to is not None:
+        kwargs["listen_to"] = listen_to
+
+    listen_event_mock = mocker.patch.object(Hass, "listen_event")
+    deconz_integration = DeCONZIntegration(fake_controller, kwargs)
+
+    with wrap_execution(error_expected=expected_id is None, exception=ValueError):
+        await deconz_integration.listen_changes("controller_id")
+
+    if expected_id is not None:
+        listen_event_mock.assert_called_once_with(
+            fake_controller,
+            deconz_integration.event_callback,
+            "deconz_event",
+            **{expected_id: "controller_id"}
+        )
diff --git a/tests/unit_tests/cx_core/integration/lutron_test.py b/tests/unit_tests/cx_core/integration/lutron_test.py
index fd284151..4bb84ea0 100644
--- a/tests/unit_tests/cx_core/integration/lutron_test.py
+++ b/tests/unit_tests/cx_core/integration/lutron_test.py
@@ -1,6 +1,7 @@
 from typing import Dict
 
 import pytest
+from appdaemon.plugins.hass.hassapi import Hass
 from cx_core.controller import Controller
 from cx_core.integration.lutron_caseta import LutronIntegration
 from pytest_mock.plugin import MockerFixture
@@ -42,5 +43,24 @@ async def test_callback(
 ):
     handle_action_patch = mocker.patch.object(fake_controller, "handle_action")
     lutron_integration = LutronIntegration(fake_controller, {})
-    await lutron_integration.callback("test", data, {})
+    await lutron_integration.event_callback("test", data, {})
     handle_action_patch.assert_called_once_with(expected, extra=data)
+
+
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+):
+    controller_id = "controller_id"
+    listen_event_mock = mocker.patch.object(Hass, "listen_event")
+    lutron_integration = LutronIntegration(fake_controller, {})
+
+    await lutron_integration.listen_changes(controller_id)
+
+    listen_event_mock.assert_called_once_with(
+        fake_controller,
+        lutron_integration.event_callback,
+        "lutron_caseta_button_event",
+        serial=controller_id,
+    )
diff --git a/tests/unit_tests/cx_core/integration/mqtt_test.py b/tests/unit_tests/cx_core/integration/mqtt_test.py
index e2dd3c18..c62efd63 100644
--- a/tests/unit_tests/cx_core/integration/mqtt_test.py
+++ b/tests/unit_tests/cx_core/integration/mqtt_test.py
@@ -1,6 +1,7 @@
 from typing import Dict
 
 import pytest
+from appdaemon.plugins.mqtt.mqttapi import Mqtt
 from cx_core.controller import Controller
 from cx_core.integration.mqtt import MQTTIntegration
 from pytest_mock.plugin import MockerFixture
@@ -34,3 +35,22 @@ async def test_callback(
         handle_action_patch.assert_called_once_with(expected)
     else:
         handle_action_patch.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+):
+    controller_id = "controller_id"
+    listen_event_mock = mocker.patch.object(Mqtt, "listen_event")
+    mqtt_integration = MQTTIntegration(fake_controller, {})
+
+    await mqtt_integration.listen_changes(controller_id)
+
+    listen_event_mock.assert_called_once_with(
+        fake_controller,
+        mqtt_integration.event_callback,
+        topic=controller_id,
+        namespace="mqtt",
+    )
diff --git a/tests/unit_tests/cx_core/integration/state_test.py b/tests/unit_tests/cx_core/integration/state_test.py
new file mode 100644
index 00000000..a781511d
--- /dev/null
+++ b/tests/unit_tests/cx_core/integration/state_test.py
@@ -0,0 +1,43 @@
+from typing import Optional
+
+import pytest
+from appdaemon.plugins.hass.hassapi import Hass
+from cx_core.controller import Controller
+from cx_core.integration.state import StateIntegration
+from pytest_mock.plugin import MockerFixture
+
+
+@pytest.mark.parametrize("attribute", ["sensor", "entity_id", None])
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller, mocker: MockerFixture, attribute: Optional[str]
+):
+    kwargs = {}
+    if attribute is not None:
+        kwargs["attribute"] = attribute
+    controller_id = "controller_id"
+    state_event_mock = mocker.patch.object(Hass, "listen_state")
+    state_integration = StateIntegration(fake_controller, kwargs)
+
+    await state_integration.listen_changes(controller_id)
+
+    state_event_mock.assert_called_once_with(
+        fake_controller,
+        state_integration.state_callback,
+        controller_id,
+        attribute=attribute,
+    )
+
+
+@pytest.mark.asyncio
+async def test_callback(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+):
+
+    handle_action_patch = mocker.patch.object(fake_controller, "handle_action")
+    state_integration = StateIntegration(fake_controller, {})
+
+    await state_integration.state_callback("test", None, "old_state", "new_state", {})
+
+    handle_action_patch.assert_called_once_with("new_state")
diff --git a/tests/unit_tests/cx_core/integration/z2m_test.py b/tests/unit_tests/cx_core/integration/z2m_test.py
index b5d0d581..553ca3f1 100644
--- a/tests/unit_tests/cx_core/integration/z2m_test.py
+++ b/tests/unit_tests/cx_core/integration/z2m_test.py
@@ -2,10 +2,14 @@
 from typing import Any, Dict, Optional
 
 import pytest
+from appdaemon.plugins.hass.hassapi import Hass
+from appdaemon.plugins.mqtt.mqttapi import Mqtt
 from cx_core.controller import Controller
 from cx_core.integration.z2m import Z2MIntegration
 from pytest_mock import MockerFixture
 
+from tests.test_utils import wrap_execution
+
 
 @pytest.mark.parametrize(
     "data, action_key, action_group, handle_action_called, expected_called_with",
@@ -56,3 +60,54 @@ async def test_event_callback(
         )
     else:
         handle_action_patch.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    "listen_to, topic_prefix, expected_id",
+    [
+        ("ha", None, "ha"),
+        (None, None, "ha"),
+        ("mqtt", None, "mqtt"),
+        ("mqtt", "my_prefix", "mqtt"),
+        ("fake", None, None),
+    ],
+)
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+    listen_to: Optional[str],
+    topic_prefix: Optional[str],
+    expected_id: str,
+):
+    kwargs = {}
+    if listen_to is not None:
+        kwargs["listen_to"] = listen_to
+    if topic_prefix is not None:
+        kwargs["topic_prefix"] = topic_prefix
+
+    hass_listen_state_mock = mocker.patch.object(Hass, "listen_state")
+    mqtt_listen_event_mock = mocker.patch.object(Mqtt, "listen_event")
+    z2m_integration = Z2MIntegration(fake_controller, kwargs)
+
+    with wrap_execution(error_expected=expected_id is None, exception=ValueError):
+        await z2m_integration.listen_changes("controller_id")
+
+    if expected_id is None:
+        return
+
+    if expected_id == "ha":
+        hass_listen_state_mock.assert_called_once_with(
+            fake_controller,
+            z2m_integration.state_callback,
+            "controller_id",
+        )
+    elif expected_id == "mqtt":
+        mqtt_listen_event_mock.assert_called_once_with(
+            fake_controller,
+            z2m_integration.event_callback,
+            topic=f"{topic_prefix or 'zigbee2mqtt'}/controller_id",
+            namespace="mqtt",
+        )
+    else:
+        assert False, "expected_id cannot be other than 'ha' or 'mqtt'"
diff --git a/tests/unit_tests/cx_core/integration/zha_test.py b/tests/unit_tests/cx_core/integration/zha_test.py
index ac86a817..68bccd6d 100644
--- a/tests/unit_tests/cx_core/integration/zha_test.py
+++ b/tests/unit_tests/cx_core/integration/zha_test.py
@@ -1,6 +1,7 @@
 from typing import Dict, Optional
 
 import pytest
+from appdaemon.plugins.hass.hassapi import Hass
 from cx_core.controller import Controller
 from cx_core.integration.zha import ZHAIntegration
 from pytest_mock.plugin import MockerFixture
@@ -48,9 +49,28 @@ async def test_callback(
     data = {"command": command, "args": args}
     handle_action_patch = mocker.patch.object(fake_controller, "handle_action")
     zha_integration = ZHAIntegration(fake_controller, {})
-    await zha_integration.callback("test", data, {})
+    await zha_integration.event_callback("test", data, {})
 
     if expected_called_with is not None:
         handle_action_patch.assert_called_once_with(expected_called_with)
     else:
         handle_action_patch.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_listen_changes(
+    fake_controller: Controller,
+    mocker: MockerFixture,
+):
+    controller_id = "controller_id"
+    listen_event_mock = mocker.patch.object(Hass, "listen_event")
+    zha_integration = ZHAIntegration(fake_controller, {})
+
+    await zha_integration.listen_changes(controller_id)
+
+    listen_event_mock.assert_called_once_with(
+        fake_controller,
+        zha_integration.event_callback,
+        "zha_event",
+        device_ieee=controller_id,
+    )
diff --git a/tests/unit_tests/cx_core/type/cover_controller_test.py b/tests/unit_tests/cx_core/type/cover_controller_test.py
index db8559ab..509c18e7 100644
--- a/tests/unit_tests/cx_core/type/cover_controller_test.py
+++ b/tests/unit_tests/cx_core/type/cover_controller_test.py
@@ -8,7 +8,7 @@
 from cx_core.type_controller import TypeController
 from pytest_mock.plugin import MockerFixture
 
-from tests.test_utils import fake_fn, wrap_exetuction
+from tests.test_utils import fake_fn, wrap_execution
 
 ENTITY_NAME = "cover.test"
 
@@ -55,7 +55,7 @@ async def test_init(
         "close_position": close_position,
     }
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         await sut_before_init.init()
 
     if not error_expected:
diff --git a/tests/unit_tests/cx_core/type/light_controller_test.py b/tests/unit_tests/cx_core/type/light_controller_test.py
index 28f422ae..29fbc060 100644
--- a/tests/unit_tests/cx_core/type/light_controller_test.py
+++ b/tests/unit_tests/cx_core/type/light_controller_test.py
@@ -12,7 +12,7 @@
 from pytest_mock.plugin import MockerFixture
 from typing_extensions import Literal
 
-from tests.test_utils import fake_fn, wrap_exetuction
+from tests.test_utils import fake_fn, wrap_execution
 
 ENTITY_NAME = "light.test"
 
@@ -74,7 +74,7 @@ async def test_init(
     sut_before_init.args["light"] = light_input
 
     # SUT
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         await sut_before_init.init()
 
     # Checks
@@ -126,7 +126,7 @@ async def test_get_attribute(
     sut.feature_support._supported_features = supported_features
     sut.entity = LightEntity(ENTITY_NAME, color_mode=color_mode)
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         output = await sut.get_attribute(attribute_input)
 
     if not error_expected:
@@ -163,7 +163,7 @@ async def test_get_value_attribute(
 
     mocker.patch.object(sut, "get_entity_state", fake_fn(expected_output, async_=True))
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         output = await sut.get_value_attribute(attribute_input)
 
     if not error_expected:
diff --git a/tests/unit_tests/cx_core/type_controller_test.py b/tests/unit_tests/cx_core/type_controller_test.py
index 26c0a30c..746bd6f7 100644
--- a/tests/unit_tests/cx_core/type_controller_test.py
+++ b/tests/unit_tests/cx_core/type_controller_test.py
@@ -6,7 +6,7 @@
 from cx_core.type_controller import Entity, TypeController
 from pytest_mock.plugin import MockerFixture
 
-from tests.test_utils import fake_fn, wrap_exetuction
+from tests.test_utils import fake_fn, wrap_execution
 
 ENTITY_ARG = "my_entity"
 ENTITY_NAME = "domain_1.test"
@@ -67,7 +67,7 @@ async def test_init(
 ):
     sut_before_init.args = args
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         await sut_before_init.init()
 
     if not error_expected:
@@ -123,7 +123,7 @@ async def test_check_domain(
     my_entity = MyEntity(entity, entities=entities)
     monkeypatch.setattr(sut, "get_state", fake_fn(to_return=entities, async_=True))
 
-    with wrap_exetuction(error_expected=error_expected, exception=ValueError):
+    with wrap_execution(error_expected=error_expected, exception=ValueError):
         sut._check_domain(my_entity)
 
 
@@ -157,7 +157,7 @@ async def fake_get_state(entity, attribute=None):
     monkeypatch.setattr(sut, "get_state", fake_get_state)
 
     sut.entity = MyEntity(entity_input)
-    with wrap_exetuction(error_expected=expected_calls is None, exception=ValueError):
+    with wrap_execution(error_expected=expected_calls is None, exception=ValueError):
         await sut.get_entity_state(attribute="attribute_test")
 
     if expected_calls is not None: