aiohomematic-test-support 2025.12.42__py3-none-any.whl → 2026.1.40__py3-none-any.whl

aiohomematic_test_support/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
 """
 Test support infrastructure for aiohomematic.
 
@@ -16,6 +18,8 @@ Key Components
   playback support for deterministic testing.
 - **helper**: Test helper utilities for common testing operations.
 - **const**: Test-specific constants and configuration values.
+- **event_capture**: Event capture and assertion utilities for behavior testing.
+- **event_mock**: Event-driven mock server for test triggers.
 
 Usage Example
 -------------
@@ -33,6 +37,33 @@ Using the factory to create a test central with session playback:
     device = central.device_coordinator.get_device_by_address("VCU0000001")
     await central.stop()
 
+Using EventCapture for behavior-focused testing:
+
+    from aiohomematic_test_support.event_capture import EventCapture
+    from aiohomematic.central.events import CircuitBreakerTrippedEvent
+
+    capture = EventCapture()
+    capture.subscribe_to(central.event_bus, CircuitBreakerTrippedEvent)
+
+    # ... trigger failures ...
+
+    capture.assert_event_emitted(CircuitBreakerTrippedEvent, failure_count=5)
+    capture.cleanup()
+
+Using EventDrivenMockServer for event-triggered test behavior:
+
+    from aiohomematic_test_support.event_mock import EventDrivenMockServer
+    from aiohomematic.central.events import DataRefreshTriggeredEvent
+
+    mock_server = EventDrivenMockServer(event_bus=central.event_bus)
+    mock_server.when(DataRefreshTriggeredEvent).then_call(
+        lambda event: inject_mock_data()
+    )
+
+    # ... trigger refresh ...
+
+    mock_server.cleanup()
+
 The session player replays pre-recorded backend responses, enabling fast and
 reproducible tests without backend dependencies.
 
@@ -45,4 +76,4 @@ test dependencies to access test support functionality.
 
 from __future__ import annotations
 
-__version__ = "2025.12.42"
+__version__ = "2026.1.40"

aiohomematic_test_support/const.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
 """Constants for tests."""
 
 from __future__ import annotations

aiohomematic_test_support/event_capture.py

@@ -0,0 +1,257 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
+"""
+Event capture utilities for test verification.
+
+This module provides tools for capturing and asserting events in tests,
+enabling behavior-focused testing through event verification.
+
+Public API
+----------
+- EventCapture: Capture events for test verification
+- EventSequenceAssertion: Verify event ordering
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from aiohomematic.central.events import Event, EventBus
+
+T = TypeVar("T", bound="Event")
+
+
+@dataclass
+class EventCapture:
+    """
+    Capture events from EventBus for test verification.
+
+    Provides methods to subscribe to events, capture them, and make assertions
+    about what events were emitted during test execution.
+
+    Example:
+    -------
+        capture = EventCapture()
+        capture.subscribe_to(event_bus, CircuitBreakerTrippedEvent)
+
+        # ... perform test actions ...
+
+        capture.assert_event_emitted(
+            CircuitBreakerTrippedEvent,
+            interface_id="test",
+            failure_count=5,
+        )
+        capture.cleanup()
+
+    """
+
+    captured_events: list[Event] = field(default_factory=list)
+    """List of all captured events."""
+
+    _unsubscribers: list[Callable[[], None]] = field(default_factory=list)
+    """Unsubscribe callbacks for cleanup."""
+
+    def assert_event_emitted(
+        self,
+        *,
+        event_type: type[Event],
+        count: int | None = None,
+        **expected_attrs: Any,
+    ) -> None:
+        """
+        Assert that an event with specific attributes was emitted.
+
+        Args:
+            event_type: The expected event type
+            count: If provided, assert exactly this many events were emitted
+            **expected_attrs: Expected attribute values on the event
+
+        Raises:
+            AssertionError: If no matching event found or count mismatch
+
+        """
+        events = self.get_events_of_type(event_type=event_type)
+
+        if count is not None and len(events) != count:
+            raise AssertionError(f"Expected {count} {event_type.__name__} events, got {len(events)}")
+
+        if not expected_attrs:
+            if not events:
+                raise AssertionError(f"No {event_type.__name__} events captured")
+            return
+
+        for event in events:
+            if all(getattr(event, k, None) == v for k, v in expected_attrs.items()):
+                return
+
+        raise AssertionError(
+            f"No {event_type.__name__} found with attributes {expected_attrs}. Captured {len(events)} events: {events}"
+        )
+
+    def assert_no_event(self, *, event_type: type[Event]) -> None:
+        """
+        Assert that no events of a specific type were emitted.
+
+        Args:
+            event_type: The event type that should not exist
+
+        Raises:
+            AssertionError: If any events of that type were captured
+
+        """
+        if events := self.get_events_of_type(event_type=event_type):
+            raise AssertionError(f"Expected no {event_type.__name__} events, but found {len(events)}: {events}")
+
+    def cleanup(self) -> None:
+        """Unsubscribe from all events and clear captured events."""
+        for unsub in self._unsubscribers:
+            unsub()
+        self._unsubscribers.clear()
+        self.captured_events.clear()
+
+    def clear(self) -> None:
+        """Clear all captured events."""
+        self.captured_events.clear()
+
+    def get_event_count(self, *, event_type: type[Event]) -> int:
+        """
+        Return count of captured events of a specific type.
+
+        Args:
+            event_type: The event type to count
+
+        Returns:
+            Number of events of that type
+
+        """
+        return len(self.get_events_of_type(event_type=event_type))
+
+    def get_events_of_type(self, *, event_type: type[T]) -> list[T]:
+        """
+        Return all captured events of a specific type.
+
+        Args:
+            event_type: The event type to filter by
+
+        Returns:
+            List of events matching the type
+
+        """
+        return [e for e in self.captured_events if isinstance(e, event_type)]
+
+    def subscribe_to(self, event_bus: EventBus, *event_types: type[Event]) -> None:
+        """
+        Subscribe to specific event types on the EventBus.
+
+        Args:
+            event_bus: The EventBus to subscribe to
+            *event_types: Event types to capture
+
+        """
+        for event_type in event_types:
+            self._unsubscribers.append(
+                event_bus.subscribe(
+                    event_type=event_type,
+                    event_key=None,
+                    handler=self._capture_handler,
+                )
+            )
+
+    def _capture_handler(self, *, event: Event) -> None:
+        """Handle event by capturing it."""
+        self.captured_events.append(event)
+
+
+@dataclass
+class EventSequenceAssertion:
+    """
+    Assert events occur in expected sequence.
+
+    Useful for verifying state machine transitions and multi-step processes.
+
+    Example:
+    -------
+        sequence = EventSequenceAssertion(expected_sequence=[
+            ConnectionStageChangedEvent,
+            ClientStateChangedEvent,
+            CentralStateChangedEvent,
+        ])
+        event_bus.subscribe(Event, sequence.on_event)
+
+        # ... perform actions ...
+
+        sequence.verify()
+
+    """
+
+    expected_sequence: list[type[Event]]
+    """The expected sequence of event types."""
+
+    captured_types: list[type[Event]] = field(default_factory=list)
+    """Captured event types in order."""
+
+    def on_event(self, *, event: Event) -> None:
+        """
+        Handle event by capturing its type.
+
+        Args:
+            event: The event that was published
+
+        """
+        self.captured_types.append(type(event))
+
+    def reset(self) -> None:
+        """Reset captured types for reuse."""
+        self.captured_types.clear()
+
+    def verify(self, *, strict: bool = False) -> None:
+        """
+        Verify the captured sequence matches expected.
+
+        Args:
+            strict: If True, require exact sequence match.
+                    If False, verify expected events appear in order
+                    (other events may be interspersed).
+
+        Raises:
+            AssertionError: If sequence doesn't match
+
+        """
+        if strict:
+            self._verify_strict()
+        else:
+            self._verify_subsequence()
+
+    def _verify_strict(self) -> None:
+        """Verify exact sequence match."""
+        if len(self.captured_types) != len(self.expected_sequence):
+            raise AssertionError(
+                f"Expected {len(self.expected_sequence)} events, "
+                f"got {len(self.captured_types)}.\n"
+                f"Expected: {[e.__name__ for e in self.expected_sequence]}\n"
+                f"Got: {[e.__name__ for e in self.captured_types]}"
+            )
+
+        for i, (expected, actual) in enumerate(zip(self.expected_sequence, self.captured_types, strict=True)):
+            if expected != actual:
+                raise AssertionError(f"Event {i}: expected {expected.__name__}, got {actual.__name__}")
+
+    def _verify_subsequence(self) -> None:
+        """Verify expected events appear in order (non-strict)."""
+        expected_idx = 0
+        for actual_type in self.captured_types:
+            if expected_idx >= len(self.expected_sequence):
+                break
+            if actual_type == self.expected_sequence[expected_idx]:
+                expected_idx += 1
+
+        if expected_idx < len(self.expected_sequence):
+            missing = self.expected_sequence[expected_idx:]
+            raise AssertionError(
+                f"Missing expected events in sequence: {[e.__name__ for e in missing]}\n"
+                f"Expected: {[e.__name__ for e in self.expected_sequence]}\n"
+                f"Got: {[e.__name__ for e in self.captured_types]}"
+            )

aiohomematic_test_support/event_mock.py

@@ -0,0 +1,300 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
+"""
+Event-driven mock server for test triggers.
+
+Overview
+--------
+This module provides a mock server that responds to events by injecting
+data or triggering actions. This enables event-based test orchestration
+where test behavior is triggered by events rather than explicit calls.
+
+The EventDrivenMockServer allows tests to:
+- Configure responses to specific event types
+- Inject mock data when certain events are published
+- Build complex test scenarios with event-driven behavior
+
+Public API
+----------
+- EventDrivenMockServer: Main mock server class
+- ResponseBuilder: Fluent builder for configuring responses
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from aiohomematic.central.events import Event, EventBus
+
+
+@dataclass
+class MockAction:
+    """
+    An action to perform when an event is received.
+
+    Attributes:
+    ----------
+        handler: The callback to invoke when the event is received
+        filter_fn: Optional filter function to match specific events
+        one_shot: If True, the action is removed after first invocation
+
+    """
+
+    handler: Callable[[Any], Any]
+    filter_fn: Callable[[Any], bool] | None = None
+    one_shot: bool = False
+
+
+@dataclass
+class EventDrivenMockServer:
+    """
+    Mock server that responds to events.
+
+    Provides a fluent API for configuring responses to specific event types.
+    When an event is published that matches a configured response, the
+    corresponding action is executed.
+
+    Example Usage
+    -------------
+        mock_server = EventDrivenMockServer(event_bus=central.event_bus)
+
+        # Configure response to inject data when refresh is triggered
+        mock_server.when(DataRefreshTriggeredEvent).then_call(
+            lambda event: inject_mock_data()
+        )
+
+        # Configure one-shot response
+        mock_server.when(CircuitBreakerTrippedEvent).once().then_call(
+            lambda event: trigger_recovery()
+        )
+
+        # Later, cleanup:
+        mock_server.cleanup()
+
+    """
+
+    _event_bus: EventBus = field(repr=False)
+    """The EventBus to subscribe to."""
+
+    _responses: dict[type[Event], list[MockAction]] = field(default_factory=dict)
+    """Mapping of event types to their configured actions."""
+
+    _unsubscribers: list[Callable[[], None]] = field(default_factory=list)
+    """Unsubscribe callbacks for cleanup."""
+
+    _invocation_count: dict[type[Event], int] = field(default_factory=dict)
+    """Count of invocations per event type."""
+
+    def cleanup(self) -> None:
+        """Unsubscribe from all events and clear responses."""
+        for unsub in self._unsubscribers:
+            unsub()
+        self._unsubscribers.clear()
+        self._responses.clear()
+        self._invocation_count.clear()
+
+    def get_invocation_count(self, *, event_type: type[Event]) -> int:
+        """
+        Return the number of times handlers were invoked for an event type.
+
+        Args:
+        ----
+            event_type: The event type to query
+
+        Returns:
+        -------
+            Number of handler invocations
+
+        """
+        return self._invocation_count.get(event_type, 0)
+
+    def when[T: Event](self, *, event_type: type[T]) -> ResponseBuilder[T]:
+        """
+        Start configuring a response for an event type.
+
+        Args:
+        ----
+            event_type: The event type to respond to
+
+        Returns:
+        -------
+            A ResponseBuilder for configuring the response
+
+        """
+        return ResponseBuilder(mock_server=self, event_type=event_type)
+
+    def _add_response(
+        self,
+        *,
+        event_type: type[Event],
+        action: MockAction,
+    ) -> None:
+        """
+        Add a response for an event type.
+
+        If this is the first response for this event type, subscribe to it.
+
+        Args:
+        ----
+            event_type: The event type to respond to
+            action: The action to perform
+
+        """
+        if event_type not in self._responses:
+            self._responses[event_type] = []
+            # Subscribe to this event type
+            unsub = self._event_bus.subscribe(
+                event_type=event_type,
+                event_key=None,
+                handler=lambda event, et=event_type: self._on_event(event=event, event_type=et),
+            )
+            self._unsubscribers.append(unsub)
+
+        self._responses[event_type].append(action)
+
+    def _on_event(self, *, event: Event, event_type: type[Event]) -> None:
+        """
+        Handle an event by invoking matching responses.
+
+        Args:
+        ----
+            event: The event that was published
+            event_type: The event type (for lookup)
+
+        """
+        if event_type not in self._responses:
+            return
+
+        # Track invocations
+        self._invocation_count[event_type] = self._invocation_count.get(event_type, 0) + 1
+
+        # Process actions (copy list to allow modification during iteration)
+        actions_to_remove: list[MockAction] = []
+        for action in list(self._responses[event_type]):
+            # Check filter if present
+            if action.filter_fn is not None and not action.filter_fn(event):
+                continue
+
+            # Invoke handler
+            action.handler(event)
+
+            # Mark one-shot actions for removal
+            if action.one_shot:
+                actions_to_remove.append(action)
+
+        # Remove one-shot actions
+        for action in actions_to_remove:
+            self._responses[event_type].remove(action)
+
+
+@dataclass
+class ResponseBuilder[T: "Event"]:
+    """
+    Fluent builder for configuring mock responses.
+
+    Provides a chainable API for configuring how the mock server should
+    respond to specific events.
+
+    Example:
+    -------
+        mock_server.when(SomeEvent)
+            .matching(lambda e: e.interface_id == "test")
+            .once()
+            .then_call(handler_fn)
+
+    """
+
+    mock_server: EventDrivenMockServer
+    """The mock server to configure."""
+
+    event_type: type[T]
+    """The event type being configured."""
+
+    _filter_fn: Callable[[T], bool] | None = None
+    """Optional filter function."""
+
+    _one_shot: bool = False
+    """Whether this is a one-shot response."""
+
+    def matching(self, *, filter_fn: Callable[[T], bool]) -> ResponseBuilder[T]:
+        """
+        Add a filter to match specific events.
+
+        Args:
+        ----
+            filter_fn: Function that returns True for matching events
+
+        Returns:
+        -------
+            Self for chaining
+
+        """
+        self._filter_fn = filter_fn
+        return self
+
+    def once(self) -> ResponseBuilder[T]:
+        """
+        Make this a one-shot response (removed after first invocation).
+
+        Returns
+        -------
+            Self for chaining
+
+        """
+        self._one_shot = True
+        return self
+
+    def then_call(self, *, handler: Callable[[T], Any]) -> None:
+        """
+        Configure the handler to call when the event is received.
+
+        Args:
+        ----
+            handler: Function to call with the event
+
+        """
+        self.mock_server._add_response(  # noqa: SLF001  # pylint: disable=protected-access
+            event_type=self.event_type,
+            action=MockAction(
+                handler=handler,
+                filter_fn=self._filter_fn,
+                one_shot=self._one_shot,
+            ),
+        )
+
+    def then_publish(self, *, event_factory: Callable[[T], Event]) -> None:
+        """
+        Configure the mock to publish another event when this event is received.
+
+        Args:
+        ----
+            event_factory: Function that creates the event to publish
+
+        """
+
+        def publish_handler(event: T) -> None:
+            new_event = event_factory(event)
+            self.mock_server._event_bus.publish_sync(event=new_event)  # noqa: SLF001  # pylint: disable=protected-access
+
+        self.then_call(handler=publish_handler)
+
+
+def create_event_mock_server(*, event_bus: EventBus) -> EventDrivenMockServer:
+    """
+    Create an EventDrivenMockServer instance.
+
+    Factory function for creating an event-driven mock server.
+
+    Args:
+    ----
+        event_bus: The EventBus to subscribe to
+
+    Returns:
+    -------
+        Configured EventDrivenMockServer instance
+
+    """
+    return EventDrivenMockServer(_event_bus=event_bus)

aiohomematic_test_support/factory.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
 """
 Test factories for creating CentralUnit and Client instances.
 
@@ -41,16 +43,16 @@ from unittest.mock import MagicMock, Mock, patch
 from aiohttp import ClientSession
 
 from aiohomematic.central import CentralConfig, CentralUnit
-from aiohomematic.central.integration_events import (
+from aiohomematic.central.events import (
     DataPointsCreatedEvent,
     DeviceLifecycleEvent,
     DeviceLifecycleEventType,
     DeviceTriggerEvent,
-    SystemStatusEvent,
+    SystemStatusChangedEvent,
 )
-from aiohomematic.client import ClientConfig, InterfaceConfig
+from aiohomematic.client import InterfaceConfig, create_client as create_client_func
 from aiohomematic.const import LOCAL_HOST, Interface, OptionalSettings
-from aiohomematic.interfaces.client import ClientProtocol
+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
 
@@ -116,10 +118,17 @@ class FactoryWithClient:
 
         # 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)
+            _orig_create_client = create_client_func
+
+            async def _mocked_create_client(
+                *,
+                client_deps: Any,
+                interface_config: InterfaceConfig,
+            ) -> ClientProtocol | Mock:
+                real_client = await _orig_create_client(
+                    client_deps=client_deps,
+                    interface_config=interface_config,
+                )
                 return cast(
                     Mock,
                     get_mock(
@@ -129,7 +138,7 @@ class FactoryWithClient:
                     ),
                 )
 
-            p3 = patch("aiohomematic.client.ClientConfig.create_client", _mocked_create_client)
+            p3 = patch("aiohomematic.client.create_client", _mocked_create_client)
             p3.start()
             self._patches.append(p3)
 
@@ -142,7 +151,7 @@ class FactoryWithClient:
     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(
+        central = await CentralConfig(
             name=const.CENTRAL_NAME,
             host=const.CCU_HOST,
             username=const.CCU_USERNAME,
@@ -169,7 +178,7 @@ class FactoryWithClient:
             """Handle device trigger events."""
             self.ha_event_mock(event)
 
-        def _system_status_event_handler(event: SystemStatusEvent) -> None:
+        def _system_status_event_handler(event: SystemStatusChangedEvent) -> None:
             """Handle system status events (issues, state changes)."""
             self.ha_event_mock(event)
 
@@ -190,7 +199,7 @@ class FactoryWithClient:
         )
         self._event_bus_unsubscribe_callbacks.append(
             central.event_bus.subscribe(
-                event_type=SystemStatusEvent, event_key=None, handler=_system_status_event_handler
+                event_type=SystemStatusChangedEvent, event_key=None, handler=_system_status_event_handler
             )
         )
 
@@ -293,7 +302,7 @@ async def get_pydev_ccu_central_unit_full(
         )
     }
 
-    central = CentralConfig(
+    central = await CentralConfig(
         name=const.CENTRAL_NAME,
         host=const.CCU_HOST,
         username=const.CCU_USERNAME,
@@ -303,6 +312,7 @@ async def get_pydev_ccu_central_unit_full(
         client_session=client_session,
         program_markers=(),
         sysvar_markers=(),
+        start_direct=True,
     ).create_central()
     central.event_bus.subscribe(event_type=DeviceLifecycleEvent, event_key=None, handler=device_lifecycle_event_handler)
     await central.start()

aiohomematic_test_support/helper.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
 """Helpers for tests."""
 
 from __future__ import annotations
@@ -11,7 +13,7 @@ import orjson
 
 from aiohomematic.central import CentralUnit
 from aiohomematic.const import UTF_8
-from aiohomematic.interfaces.model import CustomDataPointProtocol
+from aiohomematic.interfaces import CustomDataPointProtocol
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -19,7 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 # pylint: disable=protected-access
 
 
-def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
+def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:  # kwonly: disable
     """Load json file from disk into dict."""
     package_path = str(importlib.resources.files(anchor))
     with open(
@@ -29,7 +31,7 @@ def _load_json_file(anchor: str, resource: str, file_name: str) -> Any | None:
         return orjson.loads(fptr.read())
 
 
-def get_prepared_custom_data_point(
+def get_prepared_custom_data_point(  # kwonly: disable
     central: CentralUnit, address: str, channel_no: int
 ) -> CustomDataPointProtocol | None:
     """Return the hm custom_data_point."""
@@ -40,7 +42,7 @@ def get_prepared_custom_data_point(
     return None
 
 
-def load_device_description(file_name: str) -> Any:
+def load_device_description(file_name: str) -> Any:  # kwonly: disable
     """Load device description."""
     dev_desc = _load_json_file(anchor="pydevccu", resource="device_descriptions", file_name=file_name)
     assert dev_desc

aiohomematic_test_support/mock.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2026
 """
 Mock implementations for RPC clients with session playback.
 
@@ -50,12 +52,14 @@ import zipfile
 from aiohttp import ClientSession
 import orjson
 
+from aiohomematic.async_support import Looper
 from aiohomematic.central import CentralUnit
-from aiohomematic.client import BaseRpcProxy
+from aiohomematic.client import BaseRpcProxy, CircuitBreaker
 from aiohomematic.client.json_rpc import _JsonKey, _JsonRpcMethod
 from aiohomematic.client.rpc_proxy import _RpcMethod
 from aiohomematic.const import UTF_8, DataOperationResult, Parameter, ParamsetKey, RPCType
-from aiohomematic.store.persistent import _cleanup_params_for_session, _freeze_params, _unfreeze_params
+from aiohomematic.property_decorators import DelegatedProperty
+from aiohomematic.store import cleanup_params_for_session, freeze_params, unfreeze_params
 from aiohomematic_test_support import const
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,6 +70,7 @@ _LOGGER = logging.getLogger(__name__)
 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))
+    methods |= _get_properties(data_object=instance, decorator=DelegatedProperty)
 
     for method in dir(instance):
         if method in exclude_methods:
@@ -186,6 +191,16 @@ def get_client_session(  # noqa: C901
                             }
                         )
 
+                    if "fetch_all_device_data" in params[_JsonKey.SCRIPT]:
+                        # Return empty device data dict for InterfaceClient
+                        return _MockResponse(
+                            json_data={
+                                _JsonKey.ID: 0,
+                                _JsonKey.RESULT: {},
+                                _JsonKey.ERROR: None,
+                            }
+                        )
+
                 if method == _JsonRpcMethod.INTERFACE_SET_VALUE:
                     await self._central.event_coordinator.data_point_event(
                         interface_id=params[_JsonKey.INTERFACE],
@@ -270,11 +285,18 @@ def get_xml_rpc_proxy(  # noqa: C901
             self._player = player
             self._supported_methods: tuple[str, ...] = ()
             self._central: CentralUnit | None = None
+            # Real CircuitBreaker to provide actual metrics for tests
+            self._circuit_breaker = CircuitBreaker(interface_id="mock-interface", task_scheduler=Looper())
 
         def __getattr__(self, name: str) -> Any:
             # Start of method chain
             return _Method(name, self._invoke)
 
+        @property
+        def circuit_breaker(self) -> CircuitBreaker:
+            """Return the circuit breaker for metrics access."""
+            return self._circuit_breaker
+
         @property
         def supported_methods(self) -> tuple[str, ...]:
             """Return the supported methods."""
@@ -322,11 +344,11 @@ def get_xml_rpc_proxy(  # noqa: C901
 
             for dd in devices:
                 if ignore_devices_on_create is not None and (
-                    dd["ADDRESS"] in ignore_devices_on_create or dd["PARENT"] in ignore_devices_on_create
+                    dd["ADDRESS"] in ignore_devices_on_create or dd.get("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:
+                    if dd["ADDRESS"] in address_device_translation or dd.get("PARENT") in address_device_translation:
                         new_devices.append(dd)
                 else:
                     new_devices.append(dd)
@@ -382,7 +404,7 @@ def get_xml_rpc_proxy(  # noqa: C901
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
-def _get_instance_attributes(instance: Any) -> set[str]:
+def _get_instance_attributes(instance: Any) -> set[str]:  # kwonly: disable
     """
     Get all instance attribute names, supporting both __dict__ and __slots__.
 
@@ -479,9 +501,11 @@ def get_mock(
                     setattr(instance, attr, getattr(instance._mock_wraps, attr))
         return instance
 
-    # Step 1: Identify all @property decorated attributes on the class
+    # Step 1: Identify all @property and DelegatedProperty decorated attributes on the class
     # These need special handling because MagicMock doesn't delegate property access
     property_names = _get_properties(data_object=instance, decorator=property)
+    # Also include DelegatedProperty descriptors which are now used extensively
+    property_names |= _get_properties(data_object=instance, decorator=DelegatedProperty)
 
     # Step 2: Create a dynamic MagicMock subclass
     # We add property descriptors to this subclass that delegate to _mock_wraps.
@@ -644,7 +668,7 @@ class SessionPlayer:
             except ValueError:
                 continue
             resp = bucket_by_ts[latest_ts]
-            params = _unfreeze_params(frozen_params=frozen_params)
+            params = unfreeze_params(frozen_params=frozen_params)
 
             result.append((params, resp))
         return result
@@ -689,7 +713,7 @@ class SessionPlayer:
             return None
         if not (bucket_by_parameter := bucket_by_method.get(method)):
             return None
-        frozen_params = _freeze_params(params=_cleanup_params_for_session(params=params))
+        frozen_params = freeze_params(params=cleanup_params_for_session(params=params))
 
         # For each parameter, choose the response at the latest timestamp.
         if (bucket_by_ts := bucket_by_parameter.get(frozen_params)) is None:

{aiohomematic_test_support-2025.12.42.dist-info → aiohomematic_test_support-2026.1.40.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.12.42
+Version: 2026.1.40
 Summary: Support-only package for AioHomematic (tests/dev). Not part of production builds.
-Author-email: SukramJ <sukramj@icloud.com>
+Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>
 Project-URL: Homepage, https://github.com/SukramJ/aiohomematic
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers

aiohomematic_test_support-2026.1.40.dist-info/RECORD

@@ -0,0 +1,15 @@
+aiohomematic_test_support/__init__.py,sha256=rRlNZwaLwcBmnAdHge8raeNAkF0u_aNSYEM7N8I0i8M,2711
+aiohomematic_test_support/const.py,sha256=cYsT9WMnoxRR1zRRUFX8M7A9e0pwS3NcxKK9smXiiw8,6487
+aiohomematic_test_support/event_capture.py,sha256=9giXt8-vbPXUbG0X89Jt5Q8LfPli0y-liLVVUhiw-EM,8002
+aiohomematic_test_support/event_mock.py,sha256=sWtAqMPXxkWFNqslw2wfgXGtSM0kLMm0Lg_qkkAFE4g,8493
+aiohomematic_test_support/factory.py,sha256=U_-YrtgY-L5fo1WScR7jfCxJmHbJRueWTH9FSsC9ZCQ,12499
+aiohomematic_test_support/helper.py,sha256=r63EpCEPmWFdcxiEDR5k22AwbB112DbWJwK66iHLeU4,1468
+aiohomematic_test_support/mock.py,sha256=GYwpwH-mfaobK8DyNj3FFC2zyvATs46sx2l7V5wnqGA,32366
+aiohomematic_test_support/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aiohomematic_test_support/data/device_translation.json,sha256=owHLpCGvtMJzfCMOMMgnn7-LgN-BMKSYzi4NKINw1WQ,13290
+aiohomematic_test_support/data/full_session_randomized_ccu.zip,sha256=kKHMtJouCskAHkXaP1hHRSoWZO2cZDJ9P_EwuJuywJQ,733017
+aiohomematic_test_support/data/full_session_randomized_pydevccu.zip,sha256=_QFWSP03dkiMFdD_w-R98DS6ur4PYDQXw-DCkbJEGg4,1293240
+aiohomematic_test_support-2026.1.40.dist-info/METADATA,sha256=-UIyk1-RVR65AyJBlGgT7MAL6rci2WIEA5ozy9_OOeQ,575
+aiohomematic_test_support-2026.1.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic_test_support-2026.1.40.dist-info/top_level.txt,sha256=KmK-OiDDbrmawIsIgPWNAkpkDfWQnOoumYd9MXAiTHc,26
+aiohomematic_test_support-2026.1.40.dist-info/RECORD,,

aiohomematic_test_support-2025.12.42.dist-info/RECORD

@@ -1,13 +0,0 @@
-aiohomematic_test_support/__init__.py,sha256=_61m3I7tUF-q8k6-Vh3nz81vkCAY_W-UUcyhRrTeViw,1642
-aiohomematic_test_support/const.py,sha256=tLyvqZJlaDCs1F2OBRnJ94hUB0pu7RKk--CQGlVC_58,6430
-aiohomematic_test_support/factory.py,sha256=FoemfxruooVRViShZdW4uxHc09pCIUFSCG_goxvpVmg,12191
-aiohomematic_test_support/helper.py,sha256=Ue2tfy10_fiuMjYsc1jYPvo5sEtMF2WVKjvLnTZ0TzU,1360
-aiohomematic_test_support/mock.py,sha256=GhJjKXPIYwzmHanKQSEIjGb8-wuixa3n7cFW-m-oiKY,31097
-aiohomematic_test_support/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic_test_support/data/device_translation.json,sha256=owHLpCGvtMJzfCMOMMgnn7-LgN-BMKSYzi4NKINw1WQ,13290
-aiohomematic_test_support/data/full_session_randomized_ccu.zip,sha256=kKHMtJouCskAHkXaP1hHRSoWZO2cZDJ9P_EwuJuywJQ,733017
-aiohomematic_test_support/data/full_session_randomized_pydevccu.zip,sha256=_QFWSP03dkiMFdD_w-R98DS6ur4PYDQXw-DCkbJEGg4,1293240
-aiohomematic_test_support-2025.12.42.dist-info/METADATA,sha256=2h9S5x7EQqUEeN0oSnPGMuU8tYvv60HjCWP9hNiGe04,536
-aiohomematic_test_support-2025.12.42.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic_test_support-2025.12.42.dist-info/top_level.txt,sha256=KmK-OiDDbrmawIsIgPWNAkpkDfWQnOoumYd9MXAiTHc,26
-aiohomematic_test_support-2025.12.42.dist-info/RECORD,,