aiohomematic-test-support 2025.10.16__py3-none-any.whl → 2025.10.18__py3-none-any.whl

aiohomematic_test_support/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "2025.10.16"
+__version__ = "2025.10.18"
 """Module to support aiohomematic testing with a local client."""

aiohomematic_test_support/const.py

@@ -16,6 +16,11 @@ INTERFACE_ID = f"{CENTRAL_NAME}-{Interface.BIDCOS_RF}"
 FULL_SESSION_RANDOMIZED_PYDEVCCU = "full_session_randomized_pydevccu.zip"
 FULL_SESSION_RANDOMIZED_CCU = "full_session_randomized_ccu.zip"
 
+ALL_SESSION_FILES = [
+    FULL_SESSION_RANDOMIZED_PYDEVCCU,
+    FULL_SESSION_RANDOMIZED_CCU,
+]
+
 
 SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(

aiohomematic_test_support/factory.py

@@ -0,0 +1,220 @@
+"""Helpers for tests."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+import contextlib
+import logging
+from typing import Any, Self, cast
+from unittest.mock import MagicMock, Mock, patch
+
+from aiohttp import ClientSession
+
+from aiohomematic.central import CentralConfig, CentralUnit
+from aiohomematic.client import Client, ClientConfig, InterfaceConfig
+from aiohomematic.const import LOCAL_HOST, BackendSystemEvent, Interface
+from aiohomematic_test_support import const
+from aiohomematic_test_support.mock import SessionPlayer, get_client_session, get_mock, get_xml_rpc_proxy
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=protected-access
+class FactoryWithClient:
+    """Factory for a central with one local client."""
+
+    def __init__(
+        self,
+        *,
+        player: SessionPlayer,
+        address_device_translation: set[str] | None = None,
+        do_mock_client: bool = True,
+        exclude_methods_from_mocks: set[str] | None = None,
+        ignore_custom_device_definition_models: list[str] | None = None,
+        ignore_devices_on_create: list[str] | None = None,
+        include_properties_in_mocks: set[str] | None = None,
+        interface_configs: set[InterfaceConfig] | None = None,
+        un_ignore_list: list[str] | None = None,
+    ) -> None:
+        """Init the central factory."""
+        self._player = player
+        self.init(
+            address_device_translation=address_device_translation,
+            do_mock_client=do_mock_client,
+            exclude_methods_from_mocks=exclude_methods_from_mocks,
+            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
+            ignore_devices_on_create=ignore_devices_on_create,
+            include_properties_in_mocks=include_properties_in_mocks,
+            interface_configs=interface_configs,
+            un_ignore_list=un_ignore_list,
+        )
+        self.system_event_mock = MagicMock()
+        self.ha_event_mock = MagicMock()
+
+    def init(
+        self,
+        *,
+        address_device_translation: set[str] | None = None,
+        do_mock_client: bool = True,
+        exclude_methods_from_mocks: set[str] | None = None,
+        ignore_custom_device_definition_models: list[str] | None = None,
+        ignore_devices_on_create: list[str] | None = None,
+        include_properties_in_mocks: set[str] | None = None,
+        interface_configs: set[InterfaceConfig] | None = None,
+        un_ignore_list: list[str] | None = None,
+    ) -> Self:
+        """Init the central factory."""
+        self._address_device_translation = address_device_translation
+        self._do_mock_client = do_mock_client
+        self._exclude_methods_from_mocks = exclude_methods_from_mocks
+        self._ignore_custom_device_definition_models = ignore_custom_device_definition_models
+        self._ignore_devices_on_create = ignore_devices_on_create
+        self._include_properties_in_mocks = include_properties_in_mocks
+        self._interface_configs = (
+            interface_configs
+            if interface_configs is not None
+            else {
+                InterfaceConfig(
+                    central_name=const.CENTRAL_NAME,
+                    interface=Interface.BIDCOS_RF,
+                    port=2001,
+                )
+            }
+        )
+        self._un_ignore_list = frozenset(un_ignore_list or [])
+        self._client_session = get_client_session(
+            player=self._player,
+            address_device_translation=self._address_device_translation,
+            ignore_devices_on_create=self._ignore_devices_on_create,
+        )
+        self._xml_proxy = get_xml_rpc_proxy(
+            player=self._player,
+            address_device_translation=self._address_device_translation,
+            ignore_devices_on_create=self._ignore_devices_on_create,
+        )
+        return self
+
+    async def get_raw_central(self) -> CentralUnit:
+        """Return a central based on give address_device_translation."""
+        interface_configs = self._interface_configs if self._interface_configs else set()
+        central = CentralConfig(
+            name=const.CENTRAL_NAME,
+            host=const.CCU_HOST,
+            username=const.CCU_USERNAME,
+            password=const.CCU_PASSWORD,
+            central_id="test1234",
+            interface_configs=interface_configs,
+            client_session=self._client_session,
+            un_ignore_list=self._un_ignore_list,
+            ignore_custom_device_definition_models=frozenset(self._ignore_custom_device_definition_models or []),
+            start_direct=True,
+        ).create_central()
+
+        central.register_backend_system_callback(cb=self.system_event_mock)
+        central.register_homematic_callback(cb=self.ha_event_mock)
+
+        assert central
+        self._client_session.set_central(central=central)  # type: ignore[attr-defined]
+        self._xml_proxy.set_central(central=central)
+        return central
+
+    async def get_default_central(self, *, start: bool = True) -> CentralUnit:
+        """Return a central based on give address_device_translation."""
+        central = await self.get_raw_central()
+
+        await self._xml_proxy.do_init()
+        patch("aiohomematic.client.ClientConfig._create_xml_rpc_proxy", return_value=self._xml_proxy).start()
+        patch("aiohomematic.central.CentralUnit._identify_ip_addr", return_value=LOCAL_HOST).start()
+
+        # Optionally patch client creation to return a mocked client
+        if self._do_mock_client:
+            _orig_create_client = ClientConfig.create_client
+
+            async def _mocked_create_client(config: ClientConfig) -> Client | Mock:
+                real_client = await _orig_create_client(config)
+                return cast(
+                    Mock,
+                    get_mock(
+                        instance=real_client,
+                        exclude_methods=self._exclude_methods_from_mocks,
+                        include_properties=self._include_properties_in_mocks,
+                    ),
+                )
+
+            patch("aiohomematic.client.ClientConfig.create_client", _mocked_create_client).start()
+
+        if start:
+            await central.start()
+            await central._init_hub()
+        assert central
+        return central
+
+
+async def get_central_client_factory(
+    *,
+    player: SessionPlayer,
+    address_device_translation: set[str],
+    do_mock_client: bool,
+    ignore_devices_on_create: list[str] | None,
+    ignore_custom_device_definition_models: list[str] | None,
+    un_ignore_list: list[str] | None,
+) -> AsyncGenerator[tuple[CentralUnit, Client | Mock, FactoryWithClient]]:
+    """Return central factory."""
+    factory = FactoryWithClient(
+        player=player,
+        address_device_translation=address_device_translation,
+        do_mock_client=do_mock_client,
+        ignore_custom_device_definition_models=ignore_custom_device_definition_models,
+        ignore_devices_on_create=ignore_devices_on_create,
+        un_ignore_list=un_ignore_list,
+    )
+    central = await factory.get_default_central()
+    client = central.primary_client
+    assert client
+    try:
+        yield central, client, factory
+    finally:
+        await central.stop()
+        await central.clear_files()
+
+
+async def get_pydev_ccu_central_unit_full(
+    *,
+    port: int,
+    client_session: ClientSession | None = None,
+) -> CentralUnit:
+    """Create and yield central, after all devices have been created."""
+    device_event = asyncio.Event()
+
+    def systemcallback(system_event: Any, *args: Any, **kwargs: Any) -> None:
+        if system_event == BackendSystemEvent.DEVICES_CREATED:
+            device_event.set()
+
+    interface_configs = {
+        InterfaceConfig(
+            central_name=const.CENTRAL_NAME,
+            interface=Interface.BIDCOS_RF,
+            port=port,
+        )
+    }
+
+    central = CentralConfig(
+        name=const.CENTRAL_NAME,
+        host=const.CCU_HOST,
+        username=const.CCU_USERNAME,
+        password=const.CCU_PASSWORD,
+        central_id="test1234",
+        interface_configs=interface_configs,
+        client_session=client_session,
+        program_markers=(),
+        sysvar_markers=(),
+    ).create_central()
+    central.register_backend_system_callback(cb=systemcallback)
+    await central.start()
+
+    # Wait up to 60 seconds for the DEVICES_CREATED event which signals that all devices are available
+    with contextlib.suppress(TimeoutError):
+        await asyncio.wait_for(device_event.wait(), timeout=60)
+
+    return central

aiohomematic_test_support/helper.py

@@ -0,0 +1,45 @@
+"""Helpers for tests."""
+
+from __future__ import annotations
+
+import importlib.resources
+import logging
+import os
+from typing import Any
+
+import orjson
+
+from aiohomematic.central import CentralUnit
+from aiohomematic.const import UTF_8
+from aiohomematic.model.custom import CustomDataPoint
+
+_LOGGER = logging.getLogger(__name__)
+
+
+# pylint: disable=protected-access
+
+
+def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
+    """Load json file from disk into dict."""
+    package_path = str(importlib.resources.files(anchor))
+    with open(
+        file=os.path.join(package_path, resource, file_name),
+        encoding=UTF_8,
+    ) as fptr:
+        return orjson.loads(fptr.read())
+
+
+def get_prepared_custom_data_point(central: CentralUnit, address: str, channel_no: int) -> CustomDataPoint | None:
+    """Return the hm custom_data_point."""
+    if cdp := central.get_custom_data_point(address=address, channel_no=channel_no):
+        for dp in cdp._data_points.values():
+            dp._state_uncertain = False
+        return cdp
+    return None
+
+
+def load_device_description(file_name: str) -> Any:
+    """Load device description."""
+    dev_desc = _load_json_file(anchor="pydevccu", resource="device_descriptions", file_name=file_name)
+    assert dev_desc
+    return dev_desc

aiohomematic_test_support/{support.py → mock.py}

@@ -4,172 +4,30 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncGenerator
-import contextlib
-import importlib.resources
 import json
 import logging
 import os
-from typing import Any, Self, cast
-from unittest.mock import MagicMock, Mock, patch
+from typing import Any, cast
+from unittest.mock import MagicMock, Mock
 import zipfile
 
 from aiohttp import ClientSession
 import orjson
 
-from aiohomematic.central import CentralConfig, CentralUnit
-from aiohomematic.client import BaseRpcProxy, Client, ClientConfig, InterfaceConfig
+from aiohomematic.central import CentralUnit
+from aiohomematic.client import BaseRpcProxy
 from aiohomematic.client.json_rpc import _JsonKey, _JsonRpcMethod
 from aiohomematic.client.rpc_proxy import _RpcMethod
-from aiohomematic.const import (
-    LOCAL_HOST,
-    UTF_8,
-    BackendSystemEvent,
-    DataOperationResult,
-    Interface,
-    Parameter,
-    ParamsetKey,
-    RPCType,
-)
-from aiohomematic.model.custom import CustomDataPoint
+from aiohomematic.const import UTF_8, DataOperationResult, Parameter, ParamsetKey, RPCType
 from aiohomematic.store.persistent import _freeze_params, _unfreeze_params
 from aiohomematic_test_support import const
 
 _LOGGER = logging.getLogger(__name__)
 
-
 # pylint: disable=protected-access
-class FactoryWithClient:
-    """Factory for a central with one local client."""
-
-    def __init__(
-        self,
-        *,
-        player: SessionPlayer,
-        address_device_translation: set[str] | None = None,
-        do_mock_client: bool = True,
-        exclude_methods_from_mocks: set[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-        ignore_devices_on_create: list[str] | None = None,
-        include_properties_in_mocks: set[str] | None = None,
-        interface_configs: set[InterfaceConfig] | None = None,
-        un_ignore_list: list[str] | None = None,
-    ) -> None:
-        """Init the central factory."""
-        self._player = player
-        self.init(
-            address_device_translation=address_device_translation,
-            do_mock_client=do_mock_client,
-            exclude_methods_from_mocks=exclude_methods_from_mocks,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-            ignore_devices_on_create=ignore_devices_on_create,
-            include_properties_in_mocks=include_properties_in_mocks,
-            interface_configs=interface_configs,
-            un_ignore_list=un_ignore_list,
-        )
-        self.system_event_mock = MagicMock()
-        self.ha_event_mock = MagicMock()
-
-    def init(
-        self,
-        *,
-        address_device_translation: set[str] | None = None,
-        do_mock_client: bool = True,
-        exclude_methods_from_mocks: set[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-        ignore_devices_on_create: list[str] | None = None,
-        include_properties_in_mocks: set[str] | None = None,
-        interface_configs: set[InterfaceConfig] | None = None,
-        un_ignore_list: list[str] | None = None,
-    ) -> Self:
-        """Init the central factory."""
-        self._address_device_translation = address_device_translation
-        self._do_mock_client = do_mock_client
-        self._exclude_methods_from_mocks = exclude_methods_from_mocks
-        self._ignore_custom_device_definition_models = ignore_custom_device_definition_models
-        self._ignore_devices_on_create = ignore_devices_on_create
-        self._include_properties_in_mocks = include_properties_in_mocks
-        self._interface_configs = (
-            interface_configs
-            if interface_configs is not None
-            else {
-                InterfaceConfig(
-                    central_name=const.CENTRAL_NAME,
-                    interface=Interface.BIDCOS_RF,
-                    port=2001,
-                )
-            }
-        )
-        self._un_ignore_list = frozenset(un_ignore_list or [])
-        self._client_session = _get_client_session(
-            player=self._player,
-            address_device_translation=self._address_device_translation,
-            ignore_devices_on_create=self._ignore_devices_on_create,
-        )
-        self._xml_proxy = _get_xml_rpc_proxy(
-            player=self._player,
-            address_device_translation=self._address_device_translation,
-            ignore_devices_on_create=self._ignore_devices_on_create,
-        )
-        return self
-
-    async def get_raw_central(self) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        interface_configs = self._interface_configs if self._interface_configs else set()
-        central = CentralConfig(
-            name=const.CENTRAL_NAME,
-            host=const.CCU_HOST,
-            username=const.CCU_USERNAME,
-            password=const.CCU_PASSWORD,
-            central_id="test1234",
-            interface_configs=interface_configs,
-            client_session=self._client_session,
-            un_ignore_list=self._un_ignore_list,
-            ignore_custom_device_definition_models=frozenset(self._ignore_custom_device_definition_models or []),
-            start_direct=True,
-        ).create_central()
-
-        central.register_backend_system_callback(cb=self.system_event_mock)
-        central.register_homematic_callback(cb=self.ha_event_mock)
-
-        assert central
-        self._client_session.set_central(central=central)  # type: ignore[attr-defined]
-        self._xml_proxy.set_central(central=central)
-        return central
-
-    async def get_default_central(self, *, start: bool = True) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        central = await self.get_raw_central()
-
-        await self._xml_proxy.do_init()
-        patch("aiohomematic.client.ClientConfig._create_xml_rpc_proxy", return_value=self._xml_proxy).start()
-        patch("aiohomematic.central.CentralUnit._identify_ip_addr", return_value=LOCAL_HOST).start()
-
-        # Optionally patch client creation to return a mocked client
-        if self._do_mock_client:
-            _orig_create_client = ClientConfig.create_client
-
-            async def _mocked_create_client(config: ClientConfig) -> Client | Mock:
-                real_client = await _orig_create_client(config)
-                return cast(
-                    Mock,
-                    get_mock(
-                        instance=real_client,
-                        exclude_methods=self._exclude_methods_from_mocks,
-                        include_properties=self._include_properties_in_mocks,
-                    ),
-                )
-
-            patch("aiohomematic.client.ClientConfig.create_client", _mocked_create_client).start()
-
-        if start:
-            await central.start()
-            await central._init_hub()
-        assert central
-        return central
 
 
-def _get_not_mockable_method_names(instance: Any, exclude_methods: set[str]) -> set[str]:
+def _get_not_mockable_method_names(*, instance: Any, exclude_methods: set[str]) -> set[str]:
     """Return all relevant method names for mocking."""
     methods: set[str] = set(_get_properties(data_object=instance, decorator=property))
 
@@ -179,7 +37,7 @@ def _get_not_mockable_method_names(instance: Any, exclude_methods: set[str]) ->
     return methods
 
 
-def _get_properties(data_object: Any, decorator: Any) -> set[str]:
+def _get_properties(*, data_object: Any, decorator: Any) -> set[str]:
     """Return the object attributes by decorator."""
     cls = data_object.__class__
 
@@ -191,17 +49,7 @@ def _get_properties(data_object: Any, decorator: Any) -> set[str]:
     return {y for y in dir(cls) if isinstance(getattr(cls, y), resolved_decorator)}
 
 
-def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
-    """Load json file from disk into dict."""
-    package_path = str(importlib.resources.files(anchor))
-    with open(
-        file=os.path.join(package_path, resource, file_name),
-        encoding=UTF_8,
-    ) as fptr:
-        return orjson.loads(fptr.read())
-
-
-def _get_client_session(  # noqa: C901
+def get_client_session(  # noqa: C901
     *,
     player: SessionPlayer,
     address_device_translation: set[str] | None = None,
@@ -215,7 +63,7 @@ def _get_client_session(  # noqa: C901
     """
 
     class _MockResponse:
-        def __init__(self, json_data: dict | None) -> None:
+        def __init__(self, *, json_data: dict | None) -> None:
             # If no match is found, emulate backend error payload
             self._json = json_data or {
                 _JsonKey.RESULT: None,
@@ -224,7 +72,7 @@ def _get_client_session(  # noqa: C901
             }
             self.status = 200
 
-        async def json(self, encoding: str | None = None) -> dict[str, Any]:  # mimic aiohttp API
+        async def json(self, *, encoding: str | None = None) -> dict[str, Any]:  # mimic aiohttp API
             return self._json
 
         async def read(self) -> bytes:
@@ -266,24 +114,32 @@ def _get_client_session(  # noqa: C901
                     _JsonRpcMethod.SYSVAR_SET_FLOAT,
                     _JsonRpcMethod.SESSION_LOGOUT,
                 ):
-                    return _MockResponse({_JsonKey.ID: 0, _JsonKey.RESULT: "200", _JsonKey.ERROR: None})
+                    return _MockResponse(json_data={_JsonKey.ID: 0, _JsonKey.RESULT: "200", _JsonKey.ERROR: None})
                 if method == _JsonRpcMethod.SYSVAR_GET_ALL:
                     return _MockResponse(
-                        {_JsonKey.ID: 0, _JsonKey.RESULT: const.SYSVAR_DATA_JSON, _JsonKey.ERROR: None}
+                        json_data={_JsonKey.ID: 0, _JsonKey.RESULT: const.SYSVAR_DATA_JSON, _JsonKey.ERROR: None}
                     )
                 if method == _JsonRpcMethod.PROGRAM_GET_ALL:
                     return _MockResponse(
-                        {_JsonKey.ID: 0, _JsonKey.RESULT: const.PROGRAM_DATA_JSON, _JsonKey.ERROR: None}
+                        json_data={_JsonKey.ID: 0, _JsonKey.RESULT: const.PROGRAM_DATA_JSON, _JsonKey.ERROR: None}
                     )
                 if method == _JsonRpcMethod.REGA_RUN_SCRIPT:
                     if "get_program_descriptions" in params[_JsonKey.SCRIPT]:
                         return _MockResponse(
-                            {_JsonKey.ID: 0, _JsonKey.RESULT: const.PROGRAM_DATA_JSON_DESCRIPTION, _JsonKey.ERROR: None}
+                            json_data={
+                                _JsonKey.ID: 0,
+                                _JsonKey.RESULT: const.PROGRAM_DATA_JSON_DESCRIPTION,
+                                _JsonKey.ERROR: None,
+                            }
                         )
 
                     if "get_system_variable_descriptions" in params[_JsonKey.SCRIPT]:
                         return _MockResponse(
-                            {_JsonKey.ID: 0, _JsonKey.RESULT: const.SYSVAR_DATA_JSON_DESCRIPTION, _JsonKey.ERROR: None}
+                            json_data={
+                                _JsonKey.ID: 0,
+                                _JsonKey.RESULT: const.SYSVAR_DATA_JSON_DESCRIPTION,
+                                _JsonKey.ERROR: None,
+                            }
                         )
 
                 if method == _JsonRpcMethod.INTERFACE_SET_VALUE:
@@ -293,7 +149,7 @@ def _get_client_session(  # noqa: C901
                         parameter=params[_JsonKey.VALUE_KEY],
                         value=params[_JsonKey.VALUE],
                     )
-                    return _MockResponse({_JsonKey.ID: 0, _JsonKey.RESULT: "200", _JsonKey.ERROR: None})
+                    return _MockResponse(json_data={_JsonKey.ID: 0, _JsonKey.RESULT: "200", _JsonKey.ERROR: None})
                 if method == _JsonRpcMethod.INTERFACE_PUT_PARAMSET:
                     if params[_JsonKey.PARAMSET_KEY] == ParamsetKey.VALUES:
                         interface_id = params[_JsonKey.INTERFACE]
@@ -306,7 +162,7 @@ def _get_client_session(  # noqa: C901
                                 parameter=param,
                                 value=value,
                             )
-                    return _MockResponse({_JsonKey.RESULT: "200", _JsonKey.ERROR: None})
+                    return _MockResponse(json_data={_JsonKey.RESULT: "200", _JsonKey.ERROR: None})
 
             json_data = player.get_latest_response_by_params(
                 rpc_type=RPCType.JSON_RPC,
@@ -329,7 +185,7 @@ def _get_client_session(  # noqa: C901
                         new_devices.append(dd)
 
                 json_data[_JsonKey.RESULT] = new_devices
-            return _MockResponse(json_data)
+            return _MockResponse(json_data=json_data)
 
         async def close(self) -> None:  # compatibility
             return None
@@ -337,7 +193,7 @@ def _get_client_session(  # noqa: C901
     return cast(ClientSession, _MockClientSession())
 
 
-def _get_xml_rpc_proxy(  # noqa: C901
+def get_xml_rpc_proxy(  # noqa: C901
     *,
     player: SessionPlayer,
     address_device_translation: set[str] | None = None,
@@ -478,35 +334,8 @@ def _get_xml_rpc_proxy(  # noqa: C901
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
-async def get_central_client_factory(
-    player: SessionPlayer,
-    address_device_translation: set[str],
-    do_mock_client: bool,
-    ignore_devices_on_create: list[str] | None,
-    ignore_custom_device_definition_models: list[str] | None,
-    un_ignore_list: list[str] | None,
-) -> AsyncGenerator[tuple[CentralUnit, Client | Mock, FactoryWithClient]]:
-    """Return central factory."""
-    factory = FactoryWithClient(
-        player=player,
-        address_device_translation=address_device_translation,
-        do_mock_client=do_mock_client,
-        ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-        ignore_devices_on_create=ignore_devices_on_create,
-        un_ignore_list=un_ignore_list,
-    )
-    central = await factory.get_default_central()
-    client = central.primary_client
-    assert client
-    try:
-        yield central, client, factory
-    finally:
-        await central.stop()
-        await central.clear_files()
-
-
 def get_mock(
-    instance: Any, exclude_methods: set[str] | None = None, include_properties: set[str] | None = None, **kwargs: Any
+    *, instance: Any, exclude_methods: set[str] | None = None, include_properties: set[str] | None = None, **kwargs: Any
 ) -> Any:
     """Create a mock and copy instance attributes over mock."""
     if exclude_methods is None:
@@ -532,67 +361,15 @@ def get_mock(
     return mock
 
 
-def get_prepared_custom_data_point(central: CentralUnit, address: str, channel_no: int) -> CustomDataPoint | None:
-    """Return the hm custom_data_point."""
-    if cdp := central.get_custom_data_point(address=address, channel_no=channel_no):
-        for dp in cdp._data_points.values():
-            dp._state_uncertain = False
-        return cdp
-    return None
-
-
-async def get_pydev_ccu_central_unit_full(
-    port: int,
-    client_session: ClientSession | None = None,
-) -> CentralUnit:
-    """Create and yield central, after all devices have been created."""
-    device_event = asyncio.Event()
-
-    def systemcallback(system_event: Any, *args: Any, **kwargs: Any) -> None:
-        if system_event == BackendSystemEvent.DEVICES_CREATED:
-            device_event.set()
-
-    interface_configs = {
-        InterfaceConfig(
-            central_name=const.CENTRAL_NAME,
-            interface=Interface.BIDCOS_RF,
-            port=port,
-        )
-    }
-
-    central = CentralConfig(
-        name=const.CENTRAL_NAME,
-        host=const.CCU_HOST,
-        username=const.CCU_USERNAME,
-        password=const.CCU_PASSWORD,
-        central_id="test1234",
-        interface_configs=interface_configs,
-        client_session=client_session,
-        program_markers=(),
-        sysvar_markers=(),
-    ).create_central()
-    central.register_backend_system_callback(cb=systemcallback)
-    await central.start()
-
-    # Wait up to 60 seconds for the DEVICES_CREATED event which signals that all devices are available
-    with contextlib.suppress(TimeoutError):
-        await asyncio.wait_for(device_event.wait(), timeout=60)
-
-    return central
-
-
-def load_device_description(file_name: str) -> Any:
-    """Load device description."""
-    dev_desc = _load_json_file(anchor="pydevccu", resource="device_descriptions", file_name=file_name)
-    assert dev_desc
-    return dev_desc
-
-
 async def get_session_player(*, file_name: str) -> SessionPlayer:
     """Provide a SessionPlayer preloaded from the randomized full session JSON file."""
     player = SessionPlayer(file_id=file_name)
-    file_path = os.path.join(os.path.dirname(__file__), "data", file_name)
-    await player.load(file_path=file_path)
+    if player.supports_file_id(file_id=file_name):
+        return player
+
+    for load_fn in const.ALL_SESSION_FILES:
+        file_path = os.path.join(os.path.dirname(__file__), "data", load_fn)
+        await player.load(file_path=file_path, file_id=load_fn)
     return player
 
 
@@ -607,7 +384,16 @@ class SessionPlayer:
         """Initialize the session player."""
         self._file_id = file_id
 
-    async def load(self, *, file_path: str) -> DataOperationResult:
+    @property
+    def _secondary_file_ids(self) -> list[str]:
+        """Return the secondary store for the given file_id."""
+        return [fid for fid in self._store if fid != self._file_id]
+
+    def supports_file_id(self, *, file_id: str) -> bool:
+        """Return whether the session player supports the given file_id."""
+        return file_id in self._store
+
+    async def load(self, *, file_path: str, file_id: str) -> DataOperationResult:
         """
         Load data from disk into the dictionary.
 
@@ -616,7 +402,7 @@ class SessionPlayer:
         will be loaded.
         """
 
-        if self._store[self._file_id]:
+        if self.supports_file_id(file_id=file_id):
             return DataOperationResult.NO_LOAD
 
         if not os.path.exists(file_path):
@@ -635,7 +421,7 @@ class SessionPlayer:
                     with open(file=file_path, encoding=UTF_8) as file_pointer:
                         data = json.loads(file_pointer.read())
 
-                self._store[self._file_id] = data
+                self._store[file_id] = data
             except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
                 return DataOperationResult.LOAD_FAIL
             return DataOperationResult.LOAD_SUCCESS
@@ -643,11 +429,13 @@ class SessionPlayer:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(None, _perform_load)
 
-    def get_latest_response_by_method(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
+    def get_latest_response_by_method_for_file_id(
+        self, *, file_id: str, rpc_type: str, method: str
+    ) -> list[tuple[Any, Any]]:
         """Return latest non-expired responses for a given (rpc_type, method)."""
         result: list[Any] = []
         # Access store safely to avoid side effects from creating buckets.
-        if not (bucket_by_method := self._store[self._file_id].get(rpc_type)):
+        if not (bucket_by_method := self._store[file_id].get(rpc_type)):
             return result
         if not (bucket_by_parameter := bucket_by_method.get(method)):
             return result
@@ -665,16 +453,35 @@ class SessionPlayer:
             result.append((params, resp))
         return result
 
-    def get_latest_response_by_params(
+    def get_latest_response_by_method(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
+        """Return latest non-expired responses for a given (rpc_type, method)."""
+        if pri_result := self.get_latest_response_by_method_for_file_id(
+            file_id=self._file_id,
+            rpc_type=rpc_type,
+            method=method,
+        ):
+            return pri_result
+
+        for secondary_file_id in self._secondary_file_ids:
+            if sec_result := self.get_latest_response_by_method_for_file_id(
+                file_id=secondary_file_id,
+                rpc_type=rpc_type,
+                method=method,
+            ):
+                return sec_result
+        return pri_result
+
+    def get_latest_response_by_params_for_file_id(
         self,
         *,
+        file_id: str,
         rpc_type: str,
         method: str,
         params: Any,
     ) -> Any:
         """Return latest non-expired responses for a given (rpc_type, method, params)."""
         # Access store safely to avoid side effects from creating buckets.
-        if not (bucket_by_method := self._store[self._file_id].get(rpc_type)):
+        if not (bucket_by_method := self._store[file_id].get(rpc_type)):
             return None
         if not (bucket_by_parameter := bucket_by_method.get(method)):
             return None
@@ -689,3 +496,29 @@ class SessionPlayer:
             return bucket_by_ts[latest_ts]
         except ValueError:
             return None
+
+    def get_latest_response_by_params(
+        self,
+        *,
+        rpc_type: str,
+        method: str,
+        params: Any,
+    ) -> Any:
+        """Return latest non-expired responses for a given (rpc_type, method, params)."""
+        if pri_result := self.get_latest_response_by_params_for_file_id(
+            file_id=self._file_id,
+            rpc_type=rpc_type,
+            method=method,
+            params=params,
+        ):
+            return pri_result
+
+        for secondary_file_id in self._secondary_file_ids:
+            if sec_result := self.get_latest_response_by_params_for_file_id(
+                file_id=secondary_file_id,
+                rpc_type=rpc_type,
+                method=method,
+                params=params,
+            ):
+                return sec_result
+        return pri_result

{aiohomematic_test_support-2025.10.16.dist-info → aiohomematic_test_support-2025.10.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.10.16
+Version: 2025.10.18
 Summary: Support-only package for AioHomematic (tests/dev). Not part of production builds.
 Author-email: SukramJ <sukramj@icloud.com>
 Project-URL: Homepage, https://github.com/SukramJ/aiohomematic

aiohomematic_test_support-2025.10.18.dist-info/RECORD

@@ -0,0 +1,12 @@
+aiohomematic_test_support/__init__.py,sha256=vd4sacVZP3Omyq1nAHonJJ-mE7chdIn9ue0j2NNSUmY,93
+aiohomematic_test_support/const.py,sha256=4AGTK0gMaXPeje0Z2Hy9q11kxKW8TxiD5nIAygypXc0,19564
+aiohomematic_test_support/factory.py,sha256=fzkhkI4LqHbzlH0GkwpAWgRjAnLpKd0dbq3APiEecFk,8541
+aiohomematic_test_support/helper.py,sha256=pE687jG-KkrXZUFXnHTiydmhAvlGTjlejQoPeaH9w5w,1304
+aiohomematic_test_support/mock.py,sha256=E3lMlLR_by2ZLRV_zJtI0Ru-B7adLNp9YY43vBPi8_E,21023
+aiohomematic_test_support/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohomematic_test_support/data/full_session_randomized_ccu.zip,sha256=oN7g0CB_0kQX3qk-RSu-Rt28yW7BcplVqPYZCDqr0EU,734626
+aiohomematic_test_support/data/full_session_randomized_pydevccu.zip,sha256=_QFWSP03dkiMFdD_w-R98DS6ur4PYDQXw-DCkbJEGg4,1293240
+aiohomematic_test_support-2025.10.18.dist-info/METADATA,sha256=w_d31xurGNK8VhWJIc9zjEP_Z6p4HFcJBPq0_9qIqls,536
+aiohomematic_test_support-2025.10.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic_test_support-2025.10.18.dist-info/top_level.txt,sha256=KmK-OiDDbrmawIsIgPWNAkpkDfWQnOoumYd9MXAiTHc,26
+aiohomematic_test_support-2025.10.18.dist-info/RECORD,,

aiohomematic_test_support/client_local.py

@@ -1,361 +0,0 @@
-"""The local client-object and its methods."""
-
-from __future__ import annotations
-
-from _collections import defaultdict
-from dataclasses import dataclass
-from datetime import datetime
-import importlib.resources
-import logging
-import os
-from typing import Any, Final, cast
-
-import orjson
-
-from aiohomematic.client import _LOGGER, Client, ClientConfig
-from aiohomematic.const import (
-    ADDRESS_SEPARATOR,
-    DP_KEY_VALUE,
-    UTF_8,
-    WAIT_FOR_CALLBACK,
-    CallSource,
-    CommandRxMode,
-    DescriptionMarker,
-    DeviceDescription,
-    Interface,
-    ParameterData,
-    ParamsetKey,
-    ProductGroup,
-    ProgramData,
-    ProxyInitState,
-    SystemInformation,
-    SystemVariableData,
-)
-from aiohomematic.decorators import inspector
-from aiohomematic.support import is_channel_address
-
-LOCAL_SERIAL: Final = "0815_4711"
-BACKEND_LOCAL: Final = "PyDevCCU"
-
-
-class ClientLocal(Client):  # pragma: no cover
-    """Local client object to provide access to locally stored files."""
-
-    def __init__(self, *, client_config: ClientConfig, local_resources: LocalRessources) -> None:
-        """Initialize the Client."""
-        super().__init__(client_config=client_config)
-        self._local_resources = local_resources
-        self._paramset_descriptions_cache: dict[str, dict[ParamsetKey, dict[str, ParameterData]]] = defaultdict(
-            lambda: defaultdict(dict)
-        )
-
-    async def init_client(self) -> None:
-        """Init the client."""
-        self._system_information = await self._get_system_information()
-
-    @property
-    def available(self) -> bool:
-        """Return the availability of the client."""
-        return True
-
-    @property
-    def model(self) -> str:
-        """Return the model of the backend."""
-        return BACKEND_LOCAL
-
-    def get_product_group(self, *, model: str) -> ProductGroup:
-        """Return the product group."""
-        l_model = model.lower()
-        if l_model.startswith("hmipw"):
-            return ProductGroup.HMIPW
-        if l_model.startswith("hmip"):
-            return ProductGroup.HMIP
-        if l_model.startswith("hmw"):
-            return ProductGroup.HMW
-        if l_model.startswith("hm"):
-            return ProductGroup.HM
-        return ProductGroup.UNKNOWN
-
-    @property
-    def supports_ping_pong(self) -> bool:
-        """Return the supports_ping_pong info of the backend."""
-        return True
-
-    @property
-    def supports_push_updates(self) -> bool:
-        """Return the client supports push update."""
-        return True
-
-    async def initialize_proxy(self) -> ProxyInitState:
-        """Init the proxy has to tell the backend where to send the events."""
-        return ProxyInitState.INIT_SUCCESS
-
-    async def deinitialize_proxy(self) -> ProxyInitState:
-        """De-init to stop the backend from sending events for this remote."""
-        return ProxyInitState.DE_INIT_SUCCESS
-
-    async def stop(self) -> None:
-        """Stop depending services."""
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def fetch_all_device_data(self) -> None:
-        """Fetch all device data from the backend."""
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def fetch_device_details(self) -> None:
-        """Fetch names from the backend."""
-
-    @inspector(re_raise=False, no_raise_return=False)
-    async def is_connected(self) -> bool:
-        """
-        Perform actions required for connectivity check.
-
-        Connection is not connected, if three consecutive checks fail.
-        Return connectivity state.
-        """
-        return True
-
-    def is_callback_alive(self) -> bool:
-        """Return if XmlRPC-Server is alive based on received events for this client."""
-        return True
-
-    @inspector(re_raise=False, no_raise_return=False)
-    async def check_connection_availability(self, *, handle_ping_pong: bool) -> bool:
-        """Send ping to the backend to generate PONG event."""
-        if handle_ping_pong and self.supports_ping_pong:
-            self._ping_pong_cache.handle_send_ping(ping_ts=datetime.now())
-        return True
-
-    @inspector
-    async def execute_program(self, *, pid: str) -> bool:
-        """Execute a program on the backend."""
-        return True
-
-    @inspector
-    async def set_program_state(self, *, pid: str, state: bool) -> bool:
-        """Set the program state on the backend."""
-        return True
-
-    @inspector(measure_performance=True)
-    async def set_system_variable(self, *, legacy_name: str, value: Any) -> bool:
-        """Set a system variable on the backend."""
-        return True
-
-    @inspector
-    async def delete_system_variable(self, *, name: str) -> bool:
-        """Delete a system variable from the backend."""
-        return True
-
-    @inspector
-    async def get_system_variable(self, *, name: str) -> str:
-        """Get single system variable from the backend."""
-        return "Empty"
-
-    @inspector(re_raise=False)
-    async def get_all_system_variables(
-        self, *, markers: tuple[DescriptionMarker | str, ...]
-    ) -> tuple[SystemVariableData, ...]:
-        """Get all system variables from the backend."""
-        return ()
-
-    @inspector(re_raise=False)
-    async def get_all_programs(self, *, markers: tuple[DescriptionMarker | str, ...]) -> tuple[ProgramData, ...]:
-        """Get all programs, if available."""
-        return ()
-
-    @inspector(re_raise=False, no_raise_return={})
-    async def get_all_rooms(self) -> dict[str, set[str]]:
-        """Get all rooms, if available."""
-        return {}
-
-    @inspector(re_raise=False, no_raise_return={})
-    async def get_all_functions(self) -> dict[str, set[str]]:
-        """Get all functions, if available."""
-        return {}
-
-    async def _get_system_information(self) -> SystemInformation:
-        """Get system information of the backend."""
-        return SystemInformation(available_interfaces=(Interface.BIDCOS_RF,), serial=LOCAL_SERIAL)
-
-    @inspector(re_raise=False, measure_performance=True)
-    async def list_devices(self) -> tuple[DeviceDescription, ...] | None:
-        """Get device descriptions from the backend."""
-        if not self._local_resources:
-            _LOGGER.warning(
-                "LIST_DEVICES: missing local_resources in config for %s",
-                self.central.name,
-            )
-            return None
-        device_descriptions: list[DeviceDescription] = []
-        if local_device_descriptions := cast(
-            list[Any],
-            await self._load_all_json_files(
-                anchor=self._local_resources.anchor,
-                resource=self._local_resources.device_description_dir,
-                include_list=list(self._local_resources.address_device_translation.values()),
-                exclude_list=self._local_resources.ignore_devices_on_create,
-            ),
-        ):
-            for device_description in local_device_descriptions:
-                device_descriptions.extend(device_description)
-        return tuple(device_descriptions)
-
-    @inspector(log_level=logging.NOTSET)
-    async def get_value(
-        self,
-        *,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
-        call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
-    ) -> Any:
-        """Return a value from the backend."""
-        return
-
-    @inspector(re_raise=False, no_raise_return=set())
-    async def set_value(
-        self,
-        *,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        parameter: str,
-        value: Any,
-        wait_for_callback: int | None = WAIT_FOR_CALLBACK,
-        rx_mode: CommandRxMode | None = None,
-        check_against_pd: bool = False,
-    ) -> set[DP_KEY_VALUE]:
-        """Set single value on paramset VALUES."""
-        # store the send value in the last_value_send_cache
-        result = self._last_value_send_cache.add_set_value(
-            channel_address=channel_address, parameter=parameter, value=value
-        )
-        # fire an event to fake the state change for a simple parameter
-        await self.central.data_point_event(
-            interface_id=self.interface_id, channel_address=channel_address, parameter=parameter, value=value
-        )
-        return result
-
-    @inspector
-    async def get_paramset(
-        self,
-        *,
-        address: str,
-        paramset_key: ParamsetKey | str,
-        call_source: CallSource = CallSource.MANUAL_OR_SCHEDULED,
-    ) -> Any:
-        """
-        Return a paramset from the backend.
-
-        Address is usually the channel_address,
-        but for bidcos devices there is a master paramset at the device.
-        """
-        return {}
-
-    async def _get_paramset_description(
-        self, *, address: str, paramset_key: ParamsetKey
-    ) -> dict[str, ParameterData] | None:
-        """Get paramset description from the backend."""
-        if not self._local_resources:
-            _LOGGER.warning(
-                "GET_PARAMSET_DESCRIPTION: missing local_resources in config for %s",
-                self.central.name,
-            )
-            return None
-
-        if (
-            address not in self._paramset_descriptions_cache
-            and (file_name := self._local_resources.address_device_translation.get(address.split(ADDRESS_SEPARATOR)[0]))
-            and (
-                data := await self._load_json_file(
-                    anchor=self._local_resources.anchor,
-                    resource=self._local_resources.paramset_description_dir,
-                    file_name=file_name,
-                )
-            )
-        ):
-            self._paramset_descriptions_cache.update(data)
-
-        return self._paramset_descriptions_cache[address].get(paramset_key)
-
-    @inspector(measure_performance=True)
-    async def put_paramset(
-        self,
-        *,
-        channel_address: str,
-        paramset_key_or_link_address: ParamsetKey | str,
-        values: Any,
-        wait_for_callback: int | None = WAIT_FOR_CALLBACK,
-        rx_mode: CommandRxMode | None = None,
-        check_against_pd: bool = False,
-    ) -> set[DP_KEY_VALUE]:
-        """
-        Set paramsets manually.
-
-        Address is usually the channel_address,
-        but for bidcos devices there is a master paramset at the device.
-        """
-        # store the send value in the last_value_send_cache
-        if isinstance(paramset_key_or_link_address, str) and is_channel_address(address=paramset_key_or_link_address):
-            result = set()
-        else:
-            result = self._last_value_send_cache.add_put_paramset(
-                channel_address=channel_address,
-                paramset_key=ParamsetKey(paramset_key_or_link_address),
-                values=values,
-            )
-
-        # fire an event to fake the state change for the content of a paramset
-        for parameter in values:
-            await self.central.data_point_event(
-                interface_id=self.interface_id,
-                channel_address=channel_address,
-                parameter=parameter,
-                value=values[parameter],
-            )
-        return result
-
-    async def _load_all_json_files(
-        self,
-        *,
-        anchor: str,
-        resource: str,
-        include_list: list[str] | None = None,
-        exclude_list: list[str] | None = None,
-    ) -> list[Any] | None:
-        """Load all json files from disk into dict."""
-        if not include_list:
-            return []
-        if not exclude_list:
-            exclude_list = []
-        result: list[Any] = []
-        resource_path = os.path.join(str(importlib.resources.files(anchor)), resource)
-        for file_name in os.listdir(resource_path):
-            if file_name not in include_list or file_name in exclude_list:
-                continue
-            if file_content := await self._load_json_file(anchor=anchor, resource=resource, file_name=file_name):
-                result.append(file_content)
-        return result
-
-    async def _load_json_file(self, *, anchor: str, resource: str, file_name: str) -> Any | None:
-        """Load json file from disk into dict."""
-        package_path = str(importlib.resources.files(anchor))
-
-        def _perform_load() -> Any | None:
-            with open(
-                file=os.path.join(package_path, resource, file_name),
-                encoding=UTF_8,
-            ) as fptr:
-                return orjson.loads(fptr.read())
-
-        return await self.central.looper.async_add_executor_job(_perform_load, name="load-json-file")
-
-
-@dataclass(frozen=True, kw_only=True, slots=True)
-class LocalRessources:
-    """Dataclass with information for local client."""
-
-    address_device_translation: dict[str, str]
-    ignore_devices_on_create: list[str]
-    anchor: str = "pydevccu"
-    device_description_dir: str = "device_descriptions"
-    paramset_description_dir: str = "paramset_descriptions"

aiohomematic_test_support-2025.10.16.dist-info/RECORD

@@ -1,11 +0,0 @@
-aiohomematic_test_support/__init__.py,sha256=AH2c33h4vDkVdRr4jNak1cH5T-nLvnncMF2pbsCqJJo,93
-aiohomematic_test_support/client_local.py,sha256=gpWkbyt_iCQCwxsvKahYl4knFrzyBku5WwbR83_mgM8,12825
-aiohomematic_test_support/const.py,sha256=vatushPkwtueWUMdGkEJMTU6UB0Enxy4u7IXjUrXmJo,19468
-aiohomematic_test_support/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic_test_support/support.py,sha256=xFb7NRALsxE2sVo17DC_WdV6WmQWNRJhMUoHqpyHeKk,27610
-aiohomematic_test_support/data/full_session_randomized_ccu.zip,sha256=oN7g0CB_0kQX3qk-RSu-Rt28yW7BcplVqPYZCDqr0EU,734626
-aiohomematic_test_support/data/full_session_randomized_pydevccu.zip,sha256=_QFWSP03dkiMFdD_w-R98DS6ur4PYDQXw-DCkbJEGg4,1293240
-aiohomematic_test_support-2025.10.16.dist-info/METADATA,sha256=d0IB2LBdxzCAPQsaLD_mthR-Z_VtX9Srtkm1w0yqCMY,536
-aiohomematic_test_support-2025.10.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic_test_support-2025.10.16.dist-info/top_level.txt,sha256=KmK-OiDDbrmawIsIgPWNAkpkDfWQnOoumYd9MXAiTHc,26
-aiohomematic_test_support-2025.10.16.dist-info/RECORD,,