aiohomematic-test-support 2025.10.14__tar.gz → 2025.10.16__tar.gz

{aiohomematic_test_support-2025.10.14/aiohomematic_test_support.egg-info → aiohomematic_test_support-2025.10.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.10.14
+Version: 2025.10.16
 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
@@ -8,4 +8,5 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.13

{aiohomematic_test_support-2025.10.14 → aiohomematic_test_support-2025.10.16}/__init__.py

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

{aiohomematic_test_support-2025.10.14 → aiohomematic_test_support-2025.10.16/aiohomematic_test_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.10.14
+Version: 2025.10.16
 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
@@ -8,4 +8,5 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.13

{aiohomematic_test_support-2025.10.14 → aiohomematic_test_support-2025.10.16}/const.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from aiohomematic.client.json_rpc import _JsonKey
 from aiohomematic.const import LOCAL_HOST, Interface, ProgramData, SystemVariableData, SysvarType
 
 CENTRAL_NAME = "CentralTest"
@@ -32,7 +33,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="2",
         legacy_name="alarm_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.ALARM,
         unit=None,
         value=False,
@@ -56,7 +57,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="4",
         legacy_name="logic_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.LOGIC,
         unit=None,
         value=False,
@@ -80,7 +81,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="6",
         legacy_name="list_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.LIST,
         unit=None,
         value=0,
@@ -104,7 +105,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="8",
         legacy_name="string_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.STRING,
         unit=None,
         value="test1",
@@ -128,7 +129,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="10",
         legacy_name="float_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.FLOAT,
         unit="°C",
         value=23.2,
@@ -152,7 +153,7 @@ SYSVAR_DATA: list[SystemVariableData] = [
     SystemVariableData(
         vid="12",
         legacy_name="integer_ext",
-        description="",
+        description="HAHM",
         data_type=SysvarType.INTEGER,
         unit=None,
         value=17,
@@ -163,6 +164,31 @@ SYSVAR_DATA: list[SystemVariableData] = [
     ),
 ]
 
+
+SYSVAR_DATA_JSON = [
+    {
+        _JsonKey.ID: sv.vid,
+        _JsonKey.IS_INTERNAL: False,
+        _JsonKey.MAX_VALUE: sv.max_value,
+        _JsonKey.MIN_VALUE: sv.min_value,
+        _JsonKey.NAME: sv.legacy_name,
+        _JsonKey.TYPE: sv.data_type,
+        _JsonKey.UNIT: sv.unit,
+        _JsonKey.VALUE: sv.value,
+        _JsonKey.VALUE_LIST: ";".join(sv.values) if sv.values else None,
+    }
+    for sv in SYSVAR_DATA
+]
+SYSVAR_DATA_JSON_DESCRIPTION = [
+    {
+        _JsonKey.ID: sv.vid,
+        _JsonKey.DESCRIPTION: sv.description,
+    }
+    for sv in SYSVAR_DATA
+]
+
+SYSVAR_DATA_XML = {sv.legacy_name: sv.value for sv in SYSVAR_DATA}
+
 PROGRAM_DATA: list[ProgramData] = [
     ProgramData(
         legacy_name="p1",
@@ -181,7 +207,23 @@ PROGRAM_DATA: list[ProgramData] = [
         last_execute_time="",
     ),
 ]
-
+PROGRAM_DATA_JSON = [
+    {
+        _JsonKey.ID: p.pid,
+        _JsonKey.IS_ACTIVE: p.is_active,
+        _JsonKey.IS_INTERNAL: p.is_internal,
+        _JsonKey.LAST_EXECUTE_TIME: p.last_execute_time,
+        _JsonKey.NAME: p.legacy_name,
+    }
+    for p in PROGRAM_DATA
+]
+PROGRAM_DATA_JSON_DESCRIPTION = [
+    {
+        _JsonKey.ID: p.pid,
+        _JsonKey.DESCRIPTION: p.description,
+    }
+    for p in PROGRAM_DATA
+]
 
 ADDRESS_DEVICE_TRANSLATION = {
     "VCU3432945": "HmIP-STV.json",

{aiohomematic_test_support-2025.10.14 → aiohomematic_test_support-2025.10.16}/pyproject.toml

@@ -17,6 +17,7 @@ classifiers = [
   "Intended Audience :: Developers",
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 requires-python = ">=3.13"
 dependencies = []

{aiohomematic_test_support-2025.10.14 → aiohomematic_test_support-2025.10.16}/support.py

@@ -10,7 +10,7 @@ import importlib.resources
 import json
 import logging
 import os
-from typing import Any, Final, cast
+from typing import Any, Self, cast
 from unittest.mock import MagicMock, Mock, patch
 import zipfile
 
@@ -30,173 +30,92 @@ from aiohomematic.const import (
     Parameter,
     ParamsetKey,
     RPCType,
-    SourceOfDeviceCreation,
 )
 from aiohomematic.model.custom import CustomDataPoint
 from aiohomematic.store.persistent import _freeze_params, _unfreeze_params
 from aiohomematic_test_support import const
-from aiohomematic_test_support.client_local import ClientLocal, LocalRessources
 
 _LOGGER = logging.getLogger(__name__)
 
-EXCLUDE_METHODS_FROM_MOCKS: Final[list[str]] = []
-INCLUDE_PROPERTIES_IN_MOCKS: Final[list[str]] = []
-
 
 # pylint: disable=protected-access
-class FactoryWithLocalClient:
+class FactoryWithClient:
     """Factory for a central with one local client."""
 
-    def __init__(self, *, client_session: ClientSession | None = None):
-        """Init the central factory."""
-        self._client_session = client_session
-        self.system_event_mock = MagicMock()
-        self.ha_event_mock = MagicMock()
-
-    async def get_raw_central(
-        self,
-        *,
-        interface_config: InterfaceConfig | None,
-        un_ignore_list: list[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        interface_configs = {interface_config} if interface_config 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=frozenset(un_ignore_list or []),
-            ignore_custom_device_definition_models=frozenset(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)
-
-        return central
-
-    async def get_unpatched_default_central(
+    def __init__(
         self,
         *,
-        port: int,
-        address_device_translation: dict[str, str],
+        player: SessionPlayer,
+        address_device_translation: set[str] | None = None,
         do_mock_client: bool = True,
-        ignore_devices_on_create: list[str] | None = None,
-        un_ignore_list: list[str] | None = None,
+        exclude_methods_from_mocks: set[str] | None = None,
         ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> tuple[CentralUnit, Client | Mock]:
-        """Return a central based on give address_device_translation."""
-        interface_config = InterfaceConfig(
-            central_name=const.CENTRAL_NAME,
-            interface=Interface.BIDCOS_RF,
-            port=port,
-        )
-
-        central = await self.get_raw_central(
-            interface_config=interface_config,
-            un_ignore_list=un_ignore_list,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-        )
-
-        _client = ClientLocal(
-            client_config=ClientConfig(
-                central=central,
-                interface_config=interface_config,
-            ),
-            local_resources=LocalRessources(
-                address_device_translation=address_device_translation,
-                ignore_devices_on_create=ignore_devices_on_create if ignore_devices_on_create else [],
-            ),
-        )
-        await _client.init_client()
-        client = get_mock(_client) if do_mock_client else _client
-
-        assert central
-        assert client
-        return central, client
-
-    async def get_default_central(
-        self,
-        *,
-        port: int = const.CCU_MINI_PORT,
-        address_device_translation: dict[str, str],
-        do_mock_client: bool = True,
-        add_sysvars: bool = False,
-        add_programs: bool = False,
         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,
-        ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> tuple[CentralUnit, Client | Mock]:
-        """Return a central based on give address_device_translation."""
-        central, client = await self.get_unpatched_default_central(
-            port=port,
+    ) -> None:
+        """Init the central factory."""
+        self._player = player
+        self.init(
             address_device_translation=address_device_translation,
-            do_mock_client=True,
+            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,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
         )
+        self.system_event_mock = MagicMock()
+        self.ha_event_mock = MagicMock()
 
-        patch("aiohomematic.central.CentralUnit._get_primary_client", return_value=client).start()
-        patch("aiohomematic.client.ClientConfig.create_client", return_value=client).start()
-        patch(
-            "aiohomematic_test_support.client_local.ClientLocal.get_all_system_variables",
-            return_value=const.SYSVAR_DATA if add_sysvars else [],
-        ).start()
-        patch(
-            "aiohomematic_test_support.client_local.ClientLocal.get_all_programs",
-            return_value=const.PROGRAM_DATA if add_programs else [],
-        ).start()
-        patch("aiohomematic.central.CentralUnit._identify_ip_addr", return_value=LOCAL_HOST).start()
-
-        await central.start()
-        if new_device_addresses := central._check_for_new_device_addresses():
-            await central._create_devices(new_device_addresses=new_device_addresses, source=SourceOfDeviceCreation.INIT)
-        await central._init_hub()
-
-        assert central
-        assert client
-        return central, client
-
-
-class FactoryWithClient:
-    """Factory for a central with one local client."""
-
-    def __init__(
+    def init(
         self,
         *,
-        recorder: SessionPlayer,
-        address_device_translation: dict[str, str] | None = None,
+        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(
-            recorder=recorder,
-            address_device_translation=address_device_translation,
-            ignore_devices_on_create=ignore_devices_on_create,
+            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(
-            recorder=recorder,
-            address_device_translation=address_device_translation,
-            ignore_devices_on_create=ignore_devices_on_create,
+            player=self._player,
+            address_device_translation=self._address_device_translation,
+            ignore_devices_on_create=self._ignore_devices_on_create,
         )
-        self.system_event_mock = MagicMock()
-        self.ha_event_mock = MagicMock()
+        return self
 
-    async def get_raw_central(
-        self,
-        *,
-        interface_config: InterfaceConfig | None,
-        un_ignore_list: list[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> CentralUnit:
+    async def get_raw_central(self) -> CentralUnit:
         """Return a central based on give address_device_translation."""
-        interface_configs = {interface_config} if interface_config else set()
+        interface_configs = self._interface_configs if self._interface_configs else set()
         central = CentralConfig(
             name=const.CENTRAL_NAME,
             host=const.CCU_HOST,
@@ -205,81 +124,57 @@ class FactoryWithClient:
             central_id="test1234",
             interface_configs=interface_configs,
             client_session=self._client_session,
-            un_ignore_list=frozenset(un_ignore_list or []),
-            ignore_custom_device_definition_models=frozenset(ignore_custom_device_definition_models or []),
+            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)
 
-        return central
-
-    async def get_unpatched_default_central(
-        self,
-        *,
-        un_ignore_list: list[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> CentralUnit:
-        """Return a central based on give address_device_translation."""
-        interface_config = InterfaceConfig(
-            central_name=const.CENTRAL_NAME,
-            interface=Interface.BIDCOS_RF,
-            port=2001,
-        )
-
-        central = await self.get_raw_central(
-            interface_config=interface_config,
-            un_ignore_list=un_ignore_list,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-        )
-
         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,
-        *,
-        do_mock_client: bool = True,
-        un_ignore_list: list[str] | None = None,
-        ignore_custom_device_definition_models: list[str] | None = None,
-    ) -> tuple[CentralUnit, Client | Mock]:
+    async def get_default_central(self, *, start: bool = True) -> CentralUnit:
         """Return a central based on give address_device_translation."""
-        central = await self.get_unpatched_default_central(
-            un_ignore_list=un_ignore_list,
-            ignore_custom_device_definition_models=ignore_custom_device_definition_models,
-        )
+        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 do_mock_client:
+        if self._do_mock_client:
             _orig_create_client = ClientConfig.create_client
 
-            async def _mocked_create_client(self: ClientConfig) -> Client | Mock:
-                real_client = await _orig_create_client(self)
-                return cast(Mock, get_mock(real_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()
 
-        await central.start()
-
-        client = central.primary_client
+        if start:
+            await central.start()
+            await central._init_hub()
         assert central
-        assert client
-        return central, client
+        return central
 
 
-def _get_not_mockable_method_names(instance: Any) -> 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))
 
     for method in dir(instance):
-        if method in EXCLUDE_METHODS_FROM_MOCKS:
+        if method in exclude_methods:
             methods.add(method)
     return methods
 
@@ -306,26 +201,26 @@ def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
         return orjson.loads(fptr.read())
 
 
-def _get_client_session(
+def _get_client_session(  # noqa: C901
     *,
-    recorder: SessionPlayer,
-    address_device_translation: dict[str, str] | None = None,
+    player: SessionPlayer,
+    address_device_translation: set[str] | None = None,
     ignore_devices_on_create: list[str] | None = None,
 ) -> ClientSession:
     """
-    Provide a ClientSession-like fixture that answers via SimpleSessionRecorder (JSON-RPC).
+    Provide a ClientSession-like fixture that answers via SessionPlayer(JSON-RPC).
 
     Any POST request will be answered by looking up the latest recorded
-    JSON-RPC response in the session recorder using the provided method and params.
+    JSON-RPC response in the session player using the provided method and params.
     """
 
     class _MockResponse:
         def __init__(self, json_data: dict | None) -> None:
             # If no match is found, emulate backend error payload
             self._json = json_data or {
-                "result": None,
-                "error": {"name": "-1", "code": -1, "message": "Not found in session recorder"},
-                "id": 0,
+                _JsonKey.RESULT: None,
+                _JsonKey.ERROR: {"name": "-1", "code": -1, "message": "Not found in session player"},
+                _JsonKey.ID: 0,
             }
             self.status = 200
 
@@ -365,6 +260,32 @@ def _get_client_session(
             params = payload.get("params")
 
             if self._central:
+                if method in (
+                    _JsonRpcMethod.PROGRAM_EXECUTE,
+                    _JsonRpcMethod.SYSVAR_SET_BOOL,
+                    _JsonRpcMethod.SYSVAR_SET_FLOAT,
+                    _JsonRpcMethod.SESSION_LOGOUT,
+                ):
+                    return _MockResponse({_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}
+                    )
+                if method == _JsonRpcMethod.PROGRAM_GET_ALL:
+                    return _MockResponse(
+                        {_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}
+                        )
+
+                    if "get_system_variable_descriptions" in params[_JsonKey.SCRIPT]:
+                        return _MockResponse(
+                            {_JsonKey.ID: 0, _JsonKey.RESULT: const.SYSVAR_DATA_JSON_DESCRIPTION, _JsonKey.ERROR: None}
+                        )
+
                 if method == _JsonRpcMethod.INTERFACE_SET_VALUE:
                     await self._central.data_point_event(
                         interface_id=params[_JsonKey.INTERFACE],
@@ -372,7 +293,7 @@ def _get_client_session(
                         parameter=params[_JsonKey.VALUE_KEY],
                         value=params[_JsonKey.VALUE],
                     )
-                    return _MockResponse({"result": "200"})
+                    return _MockResponse({_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]
@@ -385,19 +306,29 @@ def _get_client_session(
                                 parameter=param,
                                 value=value,
                             )
-                    return _MockResponse({"result": "200"})
+                    return _MockResponse({_JsonKey.RESULT: "200", _JsonKey.ERROR: None})
 
-            json_data = recorder.get_latest_response_by_params(
+            json_data = player.get_latest_response_by_params(
                 rpc_type=RPCType.JSON_RPC,
                 method=str(method) if method is not None else "",
                 params=params,
             )
-            # if method == _JsonRpcMethod.INTERFACE_LIST_DEVICES:
-            #     if address_device_translation:
-            #         devices: dict[str, Any] = {}
-            #         for address, device in json_data["result"].items():
-            #             if address in address_device_translation:
-            #                 device["ADDRESS"] = address_device_translation[address]
+            if method == _JsonRpcMethod.INTERFACE_LIST_DEVICES and (
+                ignore_devices_on_create is not None or address_device_translation is not None
+            ):
+                new_devices = []
+                for dd in json_data[_JsonKey.RESULT]:
+                    if ignore_devices_on_create is not None and (
+                        dd["address"] in ignore_devices_on_create or dd["parent"] in ignore_devices_on_create
+                    ):
+                        continue
+                    if address_device_translation is not None:
+                        if dd["address"] in address_device_translation or dd["parent"] in address_device_translation:
+                            new_devices.append(dd)
+                    else:
+                        new_devices.append(dd)
+
+                json_data[_JsonKey.RESULT] = new_devices
             return _MockResponse(json_data)
 
         async def close(self) -> None:  # compatibility
@@ -408,16 +339,16 @@ def _get_client_session(
 
 def _get_xml_rpc_proxy(  # noqa: C901
     *,
-    recorder: SessionPlayer,
-    address_device_translation: dict[str, str] | None = None,
+    player: SessionPlayer,
+    address_device_translation: set[str] | None = None,
     ignore_devices_on_create: list[str] | None = None,
 ) -> BaseRpcProxy:
     """
-    Provide an BaseRpcProxy-like fixture that answers via SimpleSessionRecorder (XML-RPC).
+    Provide an BaseRpcProxy-like fixture that answers via SessionPlayer (XML-RPC).
 
     Any method call like: await proxy.system.listMethods(...)
     will be answered by looking up the latest recorded XML-RPC response
-    in the session recorder using the provided method and positional params.
+    in the session player using the provided method and positional params.
     """
 
     class _Method:
@@ -433,9 +364,9 @@ def _get_xml_rpc_proxy(  # noqa: C901
             # Forward to caller with collected method name and positional params
             return await self._caller(self._name, *args)
 
-    class _AioXmlRpcProxyFromRecorder:
+    class _AioXmlRpcProxyFromSession:
         def __init__(self) -> None:
-            self._recorder = recorder
+            self._player = player
             self._supported_methods: tuple[str, ...] = ()
             self._central: CentralUnit | None = None
 
@@ -448,6 +379,20 @@ def _get_xml_rpc_proxy(  # noqa: C901
             """Return the supported methods."""
             return self._supported_methods
 
+        async def getAllSystemVariables(self) -> dict[str, Any]:
+            """Return all system variables."""
+            return const.SYSVAR_DATA_XML
+
+        async def getParamset(self, channel_address: str, paramset: str) -> Any:
+            """Set a value."""
+            if self._central:
+                result = self._player.get_latest_response_by_params(
+                    rpc_type=RPCType.XML_RPC,
+                    method="getParamset",
+                    params=(channel_address, paramset),
+                )
+                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:
@@ -485,7 +430,7 @@ def _get_xml_rpc_proxy(  # noqa: C901
 
         async def listDevices(self) -> list[Any]:
             """Return a list of devices."""
-            devices = self._recorder.get_latest_response_by_params(
+            devices = self._player.get_latest_response_by_params(
                 rpc_type=RPCType.XML_RPC,
                 method="listDevices",
                 params="()",
@@ -495,19 +440,16 @@ def _get_xml_rpc_proxy(  # noqa: C901
             if ignore_devices_on_create is None and address_device_translation is None:
                 return cast(list[Any], devices)
 
-            for device in devices:
+            for dd in devices:
                 if ignore_devices_on_create is not None and (
-                    device["ADDRESS"] in ignore_devices_on_create or device["PARENT"] in ignore_devices_on_create
+                    dd["ADDRESS"] in ignore_devices_on_create or dd["PARENT"] in ignore_devices_on_create
                 ):
                     continue
                 if address_device_translation is not None:
-                    if (
-                        device["ADDRESS"] in address_device_translation
-                        or device["PARENT"] in address_device_translation
-                    ):
-                        new_devices.append(device)
+                    if dd["ADDRESS"] in address_device_translation or dd["PARENT"] in address_device_translation:
+                        new_devices.append(dd)
                 else:
-                    new_devices.append(device)
+                    new_devices.append(dd)
 
             return new_devices
 
@@ -517,7 +459,7 @@ def _get_xml_rpc_proxy(  # noqa: C901
 
         async def _invoke(self, method: str, *args: Any) -> Any:
             params = tuple(args)
-            return self._recorder.get_latest_response_by_params(
+            return self._player.get_latest_response_by_params(
                 rpc_type=RPCType.XML_RPC,
                 method=method,
                 params=params,
@@ -533,12 +475,12 @@ def _get_xml_rpc_proxy(  # noqa: C901
                 supported_methods.append(_RpcMethod.PING)
                 self._supported_methods = tuple(supported_methods)
 
-    return cast(BaseRpcProxy, _AioXmlRpcProxyFromRecorder())
+    return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
 async def get_central_client_factory(
-    recorder: SessionPlayer,
-    address_device_translation: dict[str, str],
+    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,
@@ -546,16 +488,16 @@ async def get_central_client_factory(
 ) -> AsyncGenerator[tuple[CentralUnit, Client | Mock, FactoryWithClient]]:
     """Return central factory."""
     factory = FactoryWithClient(
-        recorder=recorder,
+        player=player,
         address_device_translation=address_device_translation,
-        ignore_devices_on_create=ignore_devices_on_create,
-    )
-    central_client = await factory.get_default_central(
         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, client = central_client
+    central = await factory.get_default_central()
+    client = central.primary_client
+    assert client
     try:
         yield central, client, factory
     finally:
@@ -563,8 +505,15 @@ async def get_central_client_factory(
         await central.clear_files()
 
 
-def get_mock(instance: Any, **kwargs: Any) -> Any:
+def get_mock(
+    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:
+        exclude_methods = set()
+    if include_properties is None:
+        include_properties = set()
+
     if isinstance(instance, Mock):
         instance.__dict__.update(instance._mock_wraps.__dict__)
         return instance
@@ -573,8 +522,8 @@ def get_mock(instance: Any, **kwargs: Any) -> Any:
     try:
         for method_name in [
             prop
-            for prop in _get_not_mockable_method_names(instance)
-            if prop not in INCLUDE_PROPERTIES_IN_MOCKS and prop not in kwargs
+            for prop in _get_not_mockable_method_names(instance=instance, exclude_methods=exclude_methods)
+            if prop not in include_properties and prop not in kwargs
         ]:
             setattr(mock, method_name, getattr(instance, method_name))
     except Exception:
@@ -632,6 +581,13 @@ async def get_pydev_ccu_central_unit_full(
     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)
@@ -640,13 +596,6 @@ async def get_session_player(*, file_name: str) -> SessionPlayer:
     return player
 
 
-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
-
-
 class SessionPlayer:
     """Player for sessions."""
 
@@ -655,7 +604,7 @@ class SessionPlayer:
     )
 
     def __init__(self, *, file_id: str) -> None:
-        """Initialize the session recorder."""
+        """Initialize the session player."""
         self._file_id = file_id
 
     async def load(self, *, file_path: str) -> DataOperationResult: