aiohomematic-test-support 2025.11.3__tar.gz → 2025.12.3__tar.gz

{aiohomematic_test_support-2025.11.3/aiohomematic_test_support.egg-info → aiohomematic_test_support-2025.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.11.3
+Version: 2025.12.3
 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.12.3/__init__.py

@@ -0,0 +1,48 @@
+"""
+Test support infrastructure for aiohomematic.
+
+Overview
+--------
+This package provides reusable test utilities for testing aiohomematic functionality
+without requiring a live Homematic backend. It includes factories for creating test
+instances, mock implementations for RPC communication, and session playback capabilities
+for reproducible testing.
+
+Key Components
+--------------
+- **factory**: Factory classes for creating CentralUnit and Client instances with
+  pre-recorded or mocked backend responses.
+- **mock**: Mock implementations for XML-RPC and JSON-RPC clients with session
+  playback support for deterministic testing.
+- **helper**: Test helper utilities for common testing operations.
+- **const**: Test-specific constants and configuration values.
+
+Usage Example
+-------------
+Using the factory to create a test central with session playback:
+
+    from aiohomematic_test_support.factory import FactoryWithClient
+    from aiohomematic_test_support.mock import SessionPlayer
+
+    player = SessionPlayer(session_data_path="tests/data/ccu_session.zip")
+    factory = FactoryWithClient(player=player)
+    central, client = await factory()
+
+    # Test operations
+    await central.start()
+    device = central.get_device_by_address("VCU0000001")
+    await central.stop()
+
+The session player replays pre-recorded backend responses, enabling fast and
+reproducible tests without backend dependencies.
+
+Notes
+-----
+This is a separate package from the main aiohomematic library. Install with
+test dependencies to access test support functionality.
+
+"""
+
+from __future__ import annotations
+
+__version__ = "2025.12.3"

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.12.3/aiohomematic_test_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.11.3
+Version: 2025.12.3
 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.11.3 → aiohomematic_test_support-2025.12.3}/const.py

@@ -13,6 +13,13 @@ CCU_PORT = 2002
 CCU_MINI_PORT = 2003
 INTERFACE_ID = f"{CENTRAL_NAME}-{Interface.BIDCOS_RF}"
 
+# Backend info response for get_backend_info.fn script
+BACKEND_INFO_JSON = {
+    "version": "3.75.6.20240316",
+    "product": "CCU3",
+    "hostname": "ccu-test",
+}
+
 FULL_SESSION_RANDOMIZED_PYDEVCCU = "full_session_randomized_pydevccu.zip"
 FULL_SESSION_RANDOMIZED_CCU = "full_session_randomized_ccu.zip"
 

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.12.3}/factory.py

@@ -1,26 +1,56 @@
-"""Factories for tests."""
+"""
+Test factories for creating CentralUnit and Client instances.
+
+This module provides factory classes that simplify the creation of test instances
+with pre-configured mocks and session playback. Factories handle the complexity of
+setting up CentralConfig, InterfaceConfig, and mock RPC clients.
+
+Key Classes
+-----------
+- **FactoryWithClient**: Factory for creating a CentralUnit with a single mocked client.
+- **CentralClientFactory**: Factory for creating central with multiple clients.
+
+Usage Pattern
+-------------
+Factories use the builder pattern with fluent configuration:
+
+    factory = FactoryWithClient(
+        player=session_player,
+        do_mock_client=True,
+        ignore_devices_on_create=["VCU0000099"],
+    )
+    central, client = await factory()
+
+    # Use central and client for testing
+    await central.start()
+    # ... test operations ...
+    await central.stop()
+
+Public API of this module is defined by __all__.
+"""
 
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 import contextlib
 import logging
-from typing import Any, Self, cast
+from typing import 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.central.event_bus import BackendSystemEventData, HomematicEvent
+from aiohomematic.client import ClientConfig, InterfaceConfig
 from aiohomematic.const import LOCAL_HOST, BackendSystemEvent, Interface, OptionalSettings
+from aiohomematic.interfaces import ClientProtocol
 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."""
 
@@ -51,6 +81,84 @@ class FactoryWithClient:
         )
         self.system_event_mock = MagicMock()
         self.ha_event_mock = MagicMock()
+        self._event_bus_unsubscribe_handlers: list[Callable[[], None]] = []
+
+    def cleanup_event_bus_subscriptions(self) -> None:
+        """Clean up all event bus subscriptions."""
+        for unsubscribe in self._event_bus_unsubscribe_handlers:
+            unsubscribe()
+        self._event_bus_unsubscribe_handlers.clear()
+
+    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) -> ClientProtocol | 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.hub_coordinator.init_hub()
+        assert central
+        return central
+
+    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,
+            optional_settings=(OptionalSettings.ENABLE_LINKED_ENTITY_CLIMATE_ACTIVITY,),
+        ).create_central()
+
+        # Subscribe to events via event bus
+        def _system_event_handler(event: BackendSystemEventData) -> None:
+            """Handle backend system events."""
+            self.system_event_mock(event)
+
+        def _ha_event_handler(event: HomematicEvent) -> None:
+            """Handle homematic events."""
+            self.ha_event_mock(event)
+
+        self._event_bus_unsubscribe_handlers.append(
+            central.event_bus.subscribe(
+                event_type=BackendSystemEventData, event_key=None, handler=_system_event_handler
+            )
+        )
+        self._event_bus_unsubscribe_handlers.append(
+            central.event_bus.subscribe(event_type=HomematicEvent, event_key=None, handler=_ha_event_handler)
+        )
+
+        assert central
+        self._client_session.set_central(central=central)  # type: ignore[attr-defined]
+        self._xml_proxy.set_central(central=central)
+        return central
 
     def init(
         self,
@@ -95,62 +203,6 @@ class FactoryWithClient:
         )
         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,
-            optional_settings=(OptionalSettings.ENABLE_LINKED_ENTITY_CLIMATE_ACTIVITY,),
-        ).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(
     *,
@@ -160,7 +212,7 @@ async def get_central_client_factory(
     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]]:
+) -> AsyncGenerator[tuple[CentralUnit, ClientProtocol | Mock, FactoryWithClient]]:
     """Return central factory."""
     factory = FactoryWithClient(
         player=player,
@@ -176,6 +228,7 @@ async def get_central_client_factory(
     try:
         yield central, client, factory
     finally:
+        factory.cleanup_event_bus_subscriptions()
         await central.stop()
         await central.clear_files()
 
@@ -188,8 +241,9 @@ async def get_pydev_ccu_central_unit_full(
     """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:
+    def system_event_handler(event: BackendSystemEventData) -> None:
+        """Handle backend system events."""
+        if event.system_event == BackendSystemEvent.DEVICES_CREATED:
             device_event.set()
 
     interface_configs = {
@@ -211,7 +265,7 @@ async def get_pydev_ccu_central_unit_full(
         program_markers=(),
         sysvar_markers=(),
     ).create_central()
-    central.register_backend_system_callback(cb=systemcallback)
+    central.event_bus.subscribe(event_type=BackendSystemEventData, event_key=None, handler=system_event_handler)
     await central.start()
 
     # Wait up to 60 seconds for the DEVICES_CREATED event which signals that all devices are available

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.12.3}/helper.py

@@ -11,7 +11,7 @@ import orjson
 
 from aiohomematic.central import CentralUnit
 from aiohomematic.const import UTF_8
-from aiohomematic.model.custom import CustomDataPoint
+from aiohomematic.interfaces import CustomDataPointProtocol
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -29,10 +29,12 @@ def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
         return orjson.loads(fptr.read())
 
 
-def get_prepared_custom_data_point(central: CentralUnit, address: str, channel_no: int) -> CustomDataPoint | None:
+def get_prepared_custom_data_point(
+    central: CentralUnit, address: str, channel_no: int
+) -> CustomDataPointProtocol | 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():
+        for dp in cdp._data_points.values():  # type: ignore[attr-defined]
             dp._state_uncertain = False
         return cdp
     return None

{aiohomematic_test_support-2025.11.3 → aiohomematic_test_support-2025.12.3}/mock.py

@@ -1,4 +1,37 @@
-"""Mocks for tests."""
+"""
+Mock implementations for RPC clients with session playback.
+
+This module provides mock RPC proxy implementations that replay pre-recorded
+backend responses from session data files. This enables deterministic, fast
+testing without live Homematic backend dependencies.
+
+Key Classes
+-----------
+- **SessionPlayer**: Loads and plays back recorded RPC session data from ZIP archives.
+- **get_mock**: Creates mock instances of data points and devices with configurable
+  method/property exclusions.
+- **get_xml_rpc_proxy**: Returns mock XML-RPC proxy with session playback.
+- **get_client_session**: Returns mock aiohttp ClientSession for JSON-RPC tests.
+
+Session Playback
+----------------
+Session data is stored in ZIP archives containing JSON files with recorded
+RPC method calls and responses. The SessionPlayer replays these responses
+when tests invoke RPC methods:
+
+    player = SessionPlayer(session_data_path="tests/data/ccu_full.zip")
+    proxy = get_xml_rpc_proxy(player=player, interface="BidCos-RF")
+
+    # Calls return pre-recorded responses
+    devices = await proxy.listDevices()
+
+This approach provides:
+- Fast test execution (no network I/O)
+- Reproducible results (same responses every time)
+- Offline testing (no backend required)
+
+Public API of this module is defined by __all__.
+"""
 
 from __future__ import annotations
 
@@ -63,9 +96,9 @@ def get_client_session(  # noqa: C901
     """
 
     class _MockResponse:
-        def __init__(self, *, json_data: dict | None) -> None:
+        def __init__(self, *, json_data: dict[str, Any] | None) -> None:
             # If no match is found, emulate backend error payload
-            self._json = json_data or {
+            self._json: dict[str, Any] = json_data or {
                 _JsonKey.RESULT: None,
                 _JsonKey.ERROR: {"name": "-1", "code": -1, "message": "Not found in session player"},
                 _JsonKey.ID: 0,
@@ -83,9 +116,8 @@ def get_client_session(  # noqa: C901
             """Initialize the mock client session."""
             self._central: CentralUnit | None = None
 
-        def set_central(self, *, central: CentralUnit) -> None:
-            """Set the central."""
-            self._central = central
+        async def close(self) -> None:  # compatibility
+            return None
 
         async def post(
             self,
@@ -142,6 +174,15 @@ def get_client_session(  # noqa: C901
                             }
                         )
 
+                    if "get_backend_info" in params[_JsonKey.SCRIPT]:
+                        return _MockResponse(
+                            json_data={
+                                _JsonKey.ID: 0,
+                                _JsonKey.RESULT: const.BACKEND_INFO_JSON,
+                                _JsonKey.ERROR: None,
+                            }
+                        )
+
                 if method == _JsonRpcMethod.INTERFACE_SET_VALUE:
                     await self._central.data_point_event(
                         interface_id=params[_JsonKey.INTERFACE],
@@ -187,8 +228,9 @@ def get_client_session(  # noqa: C901
                 json_data[_JsonKey.RESULT] = new_devices
             return _MockResponse(json_data=json_data)
 
-        async def close(self) -> None:  # compatibility
-            return None
+        def set_central(self, *, central: CentralUnit) -> None:
+            """Set the central."""
+            self._central = central
 
     return cast(ClientSession, _MockClientSession())
 
@@ -212,29 +254,40 @@ def get_xml_rpc_proxy(  # noqa: C901
             self._name = full_name
             self._caller = caller
 
-        def __getattr__(self, sub: str) -> _Method:
-            # Allow chaining like proxy.system.listMethods
-            return _Method(f"{self._name}.{sub}", self._caller)
-
         async def __call__(self, *args: Any) -> Any:
             # Forward to caller with collected method name and positional params
             return await self._caller(self._name, *args)
 
+        def __getattr__(self, sub: str) -> _Method:
+            # Allow chaining like proxy.system.listMethods
+            return _Method(f"{self._name}.{sub}", self._caller)
+
     class _AioXmlRpcProxyFromSession:
         def __init__(self) -> None:
             self._player = player
             self._supported_methods: tuple[str, ...] = ()
             self._central: CentralUnit | None = None
 
-        def set_central(self, *, central: CentralUnit) -> None:
-            """Set the central."""
-            self._central = central
+        def __getattr__(self, name: str) -> Any:
+            # Start of method chain
+            return _Method(name, self._invoke)
 
         @property
         def supported_methods(self) -> tuple[str, ...]:
             """Return the supported methods."""
             return self._supported_methods
 
+        async def clientServerInitialized(self, interface_id: str) -> None:
+            """Answer clientServerInitialized with pong."""
+            await self.ping(callerId=interface_id)
+
+        async def do_init(self) -> None:
+            """Init the xml rpc proxy."""
+            if supported_methods := await self.system.listMethods():
+                # ping is missing in VirtualDevices interface but can be used.
+                supported_methods.append(_RpcMethod.PING)
+                self._supported_methods = tuple(supported_methods)
+
         async def getAllSystemVariables(self) -> dict[str, Any]:
             """Return all system variables."""
             return const.SYSVAR_DATA_XML
@@ -249,41 +302,6 @@ def get_xml_rpc_proxy(  # noqa: C901
                 )
                 return result if result else {}
 
-        async def setValue(self, channel_address: str, parameter: str, value: Any, rx_mode: Any | None = None) -> None:
-            """Set a value."""
-            if self._central:
-                await self._central.data_point_event(
-                    interface_id=self._central.primary_client.interface_id,  # type: ignore[union-attr]
-                    channel_address=channel_address,
-                    parameter=parameter,
-                    value=value,
-                )
-
-        async def putParamset(
-            self, channel_address: str, paramset_key: str, values: Any, rx_mode: Any | None = None
-        ) -> None:
-            """Set a paramset."""
-            if self._central and paramset_key == ParamsetKey.VALUES:
-                interface_id = self._central.primary_client.interface_id  # type: ignore[union-attr]
-                for param, value in values.items():
-                    await self._central.data_point_event(
-                        interface_id=interface_id, channel_address=channel_address, parameter=param, value=value
-                    )
-
-        async def ping(self, callerId: str) -> None:
-            """Answer ping with pong."""
-            if self._central:
-                await self._central.data_point_event(
-                    interface_id=callerId,
-                    channel_address="",
-                    parameter=Parameter.PONG,
-                    value=callerId,
-                )
-
-        async def clientServerInitialized(self, interface_id: str) -> None:
-            """Answer clientServerInitialized with pong."""
-            await self.ping(callerId=interface_id)
-
         async def listDevices(self) -> list[Any]:
             """Return a list of devices."""
             devices = self._player.get_latest_response_by_params(
@@ -309,9 +327,43 @@ def get_xml_rpc_proxy(  # noqa: C901
 
             return new_devices
 
-        def __getattr__(self, name: str) -> Any:
-            # Start of method chain
-            return _Method(name, self._invoke)
+        async def ping(self, callerId: str) -> None:
+            """Answer ping with pong."""
+            if self._central:
+                await self._central.data_point_event(
+                    interface_id=callerId,
+                    channel_address="",
+                    parameter=Parameter.PONG,
+                    value=callerId,
+                )
+
+        async def putParamset(
+            self, channel_address: str, paramset_key: str, values: Any, rx_mode: Any | None = None
+        ) -> None:
+            """Set a paramset."""
+            if self._central and paramset_key == ParamsetKey.VALUES:
+                interface_id = self._central.primary_client.interface_id  # type: ignore[union-attr]
+                for param, value in values.items():
+                    await self._central.data_point_event(
+                        interface_id=interface_id, channel_address=channel_address, parameter=param, value=value
+                    )
+
+        async def setValue(self, channel_address: str, parameter: str, value: Any, rx_mode: Any | None = None) -> None:
+            """Set a value."""
+            if self._central:
+                await self._central.data_point_event(
+                    interface_id=self._central.primary_client.interface_id,  # type: ignore[union-attr]
+                    channel_address=channel_address,
+                    parameter=parameter,
+                    value=value,
+                )
+
+        def set_central(self, *, central: CentralUnit) -> None:
+            """Set the central."""
+            self._central = central
+
+        async def stop(self) -> None:  # compatibility with AioXmlRpcProxy.stop
+            return None
 
         async def _invoke(self, method: str, *args: Any) -> Any:
             params = tuple(args)
@@ -321,16 +373,6 @@ def get_xml_rpc_proxy(  # noqa: C901
                 params=params,
             )
 
-        async def stop(self) -> None:  # compatibility with AioXmlRpcProxy.stop
-            return None
-
-        async def do_init(self) -> None:
-            """Init the xml rpc proxy."""
-            if supported_methods := await self.system.listMethods():
-                # ping is missing in VirtualDevices interface but can be used.
-                supported_methods.append(_RpcMethod.PING)
-                self._supported_methods = tuple(supported_methods)
-
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
@@ -389,45 +431,23 @@ class SessionPlayer:
         """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.
-
-        Supports plain JSON files and ZIP archives containing a JSON file.
-        When a ZIP archive is provided, the first JSON member inside the archive
-        will be loaded.
-        """
-
-        if self.supports_file_id(file_id=file_id):
-            return DataOperationResult.NO_LOAD
-
-        if not os.path.exists(file_path):
-            return DataOperationResult.NO_LOAD
-
-        def _perform_load() -> DataOperationResult:
-            try:
-                if zipfile.is_zipfile(file_path):
-                    with zipfile.ZipFile(file_path, mode="r") as zf:
-                        # Prefer json files; pick the first .json entry if available
-                        if not (json_members := [n for n in zf.namelist() if n.lower().endswith(".json")]):
-                            return DataOperationResult.LOAD_FAIL
-                        raw = zf.read(json_members[0]).decode(UTF_8)
-                        data = json.loads(raw)
-                else:
-                    with open(file=file_path, encoding=UTF_8) as file_pointer:
-                        data = json.loads(file_pointer.read())
-
-                self._store[file_id] = data
-            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
-                return DataOperationResult.LOAD_FAIL
-            return DataOperationResult.LOAD_SUCCESS
+    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
 
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, _perform_load)
+        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_method_for_file_id(
         self, *, file_id: str, rpc_type: str, method: str
@@ -453,20 +473,28 @@ class SessionPlayer:
             result.append((params, resp))
         return result
 
-    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(
+    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_method_for_file_id(
+            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
@@ -497,28 +525,41 @@ class SessionPlayer:
         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
+    async def load(self, *, file_path: str, file_id: str) -> DataOperationResult:
+        """
+        Load data from disk into the dictionary.
 
-        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
+        Supports plain JSON files and ZIP archives containing a JSON file.
+        When a ZIP archive is provided, the first JSON member inside the archive
+        will be loaded.
+        """
+        if self.supports_file_id(file_id=file_id):
+            return DataOperationResult.NO_LOAD
+
+        if not os.path.exists(file_path):
+            return DataOperationResult.NO_LOAD
+
+        def _perform_load() -> DataOperationResult:
+            try:
+                if zipfile.is_zipfile(file_path):
+                    with zipfile.ZipFile(file_path, mode="r") as zf:
+                        # Prefer json files; pick the first .json entry if available
+                        if not (json_members := [n for n in zf.namelist() if n.lower().endswith(".json")]):
+                            return DataOperationResult.LOAD_FAIL
+                        raw = zf.read(json_members[0]).decode(UTF_8)
+                        data = json.loads(raw)
+                else:
+                    with open(file=file_path, encoding=UTF_8) as file_pointer:
+                        data = json.loads(file_pointer.read())
+
+                self._store[file_id] = data
+            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
+                return DataOperationResult.LOAD_FAIL
+            return DataOperationResult.LOAD_SUCCESS
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, _perform_load)
+
+    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

aiohomematic_test_support-2025.11.3/__init__.py

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