aiohomematic-test-support 2025.12.8__tar.gz → 2025.12.26__tar.gz

{aiohomematic_test_support-2025.12.8/aiohomematic_test_support.egg-info → aiohomematic_test_support-2025.12.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.12.8
+Version: 2025.12.26
 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.8 → aiohomematic_test_support-2025.12.26}/__init__.py

@@ -30,7 +30,7 @@ Using the factory to create a test central with session playback:
 
     # Test operations
     await central.start()
-    device = central.get_device_by_address("VCU0000001")
+    device = central.device_coordinator.get_device_by_address("VCU0000001")
     await central.stop()
 
 The session player replays pre-recorded backend responses, enabling fast and
@@ -45,4 +45,4 @@ test dependencies to access test support functionality.
 
 from __future__ import annotations
 
-__version__ = "2025.12.8"
+__version__ = "2025.12.26"

{aiohomematic_test_support-2025.12.8 → aiohomematic_test_support-2025.12.26/aiohomematic_test_support.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic-test-support
-Version: 2025.12.8
+Version: 2025.12.26
 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.8 → aiohomematic_test_support-2025.12.26}/factory.py

@@ -41,10 +41,16 @@ from unittest.mock import MagicMock, Mock, patch
 from aiohttp import ClientSession
 
 from aiohomematic.central import CentralConfig, CentralUnit
-from aiohomematic.central.event_bus import BackendSystemEventData, HomematicEvent
+from aiohomematic.central.integration_events import (
+    DataPointsCreatedEvent,
+    DeviceLifecycleEvent,
+    DeviceLifecycleEventType,
+    DeviceTriggerEvent,
+    SystemStatusEvent,
+)
 from aiohomematic.client import ClientConfig, InterfaceConfig
-from aiohomematic.const import LOCAL_HOST, BackendSystemEvent, Interface, OptionalSettings
-from aiohomematic.interfaces import ClientProtocol
+from aiohomematic.const import LOCAL_HOST, Interface, OptionalSettings
+from aiohomematic.interfaces.client import ClientProtocol
 from aiohomematic_test_support import const
 from aiohomematic_test_support.mock import SessionPlayer, get_client_session, get_mock, get_xml_rpc_proxy
 
@@ -81,13 +87,13 @@ class FactoryWithClient:
         )
         self.system_event_mock = MagicMock()
         self.ha_event_mock = MagicMock()
-        self._event_bus_unsubscribe_handlers: list[Callable[[], None]] = []
+        self._event_bus_unsubscribe_callbacks: list[Callable[[], None]] = []
 
     def cleanup_event_bus_subscriptions(self) -> None:
         """Clean up all event bus subscriptions."""
-        for unsubscribe in self._event_bus_unsubscribe_handlers:
+        for unsubscribe in self._event_bus_unsubscribe_callbacks:
             unsubscribe()
-        self._event_bus_unsubscribe_handlers.clear()
+        self._event_bus_unsubscribe_callbacks.clear()
 
     async def get_default_central(self, *, start: bool = True) -> CentralUnit:
         """Return a central based on give address_device_translation."""
@@ -138,21 +144,41 @@ class FactoryWithClient:
         ).create_central()
 
         # Subscribe to events via event bus
-        def _system_event_handler(event: BackendSystemEventData) -> None:
-            """Handle backend system events."""
+        def _device_lifecycle_event_handler(event: DeviceLifecycleEvent) -> None:
+            """Handle device lifecycle events."""
             self.system_event_mock(event)
 
-        def _ha_event_handler(event: HomematicEvent) -> None:
-            """Handle homematic events."""
+        def _data_points_created_event_handler(event: DataPointsCreatedEvent) -> None:
+            """Handle data points created events."""
+            self.system_event_mock(event)
+
+        def _device_trigger_event_handler(event: DeviceTriggerEvent) -> None:
+            """Handle device trigger events."""
+            self.ha_event_mock(event)
+
+        def _system_status_event_handler(event: SystemStatusEvent) -> None:
+            """Handle system status events (issues, state changes)."""
             self.ha_event_mock(event)
 
-        self._event_bus_unsubscribe_handlers.append(
+        self._event_bus_unsubscribe_callbacks.append(
+            central.event_bus.subscribe(
+                event_type=DeviceLifecycleEvent, event_key=None, handler=_device_lifecycle_event_handler
+            )
+        )
+        self._event_bus_unsubscribe_callbacks.append(
+            central.event_bus.subscribe(
+                event_type=DataPointsCreatedEvent, event_key=None, handler=_data_points_created_event_handler
+            )
+        )
+        self._event_bus_unsubscribe_callbacks.append(
             central.event_bus.subscribe(
-                event_type=BackendSystemEventData, event_key=None, handler=_system_event_handler
+                event_type=DeviceTriggerEvent, event_key=None, handler=_device_trigger_event_handler
             )
         )
-        self._event_bus_unsubscribe_handlers.append(
-            central.event_bus.subscribe(event_type=HomematicEvent, event_key=None, handler=_ha_event_handler)
+        self._event_bus_unsubscribe_callbacks.append(
+            central.event_bus.subscribe(
+                event_type=SystemStatusEvent, event_key=None, handler=_system_status_event_handler
+            )
         )
 
         assert central
@@ -223,14 +249,14 @@ async def get_central_client_factory(
         un_ignore_list=un_ignore_list,
     )
     central = await factory.get_default_central()
-    client = central.primary_client
+    client = central.client_coordinator.primary_client
     assert client
     try:
         yield central, client, factory
     finally:
         factory.cleanup_event_bus_subscriptions()
         await central.stop()
-        await central.clear_files()
+        await central.cache_coordinator.clear_all()
 
 
 async def get_pydev_ccu_central_unit_full(
@@ -241,9 +267,9 @@ async def get_pydev_ccu_central_unit_full(
     """Create and yield central, after all devices have been created."""
     device_event = asyncio.Event()
 
-    def system_event_handler(event: BackendSystemEventData) -> None:
-        """Handle backend system events."""
-        if event.system_event == BackendSystemEvent.DEVICES_CREATED:
+    def device_lifecycle_event_handler(event: DeviceLifecycleEvent) -> None:
+        """Handle device lifecycle events."""
+        if event.event_type == DeviceLifecycleEventType.CREATED:
             device_event.set()
 
     interface_configs = {
@@ -265,7 +291,7 @@ async def get_pydev_ccu_central_unit_full(
         program_markers=(),
         sysvar_markers=(),
     ).create_central()
-    central.event_bus.subscribe(event_type=BackendSystemEventData, event_key=None, handler=system_event_handler)
+    central.event_bus.subscribe(event_type=DeviceLifecycleEvent, event_key=None, handler=device_lifecycle_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.12.8 → aiohomematic_test_support-2025.12.26}/helper.py

@@ -11,7 +11,7 @@ import orjson
 
 from aiohomematic.central import CentralUnit
 from aiohomematic.const import UTF_8
-from aiohomematic.interfaces import CustomDataPointProtocol
+from aiohomematic.interfaces.model import CustomDataPointProtocol
 
 _LOGGER = logging.getLogger(__name__)
 

{aiohomematic_test_support-2025.12.8 → aiohomematic_test_support-2025.12.26}/mock.py

@@ -37,6 +37,8 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
+from collections.abc import Callable
+import contextlib
 import json
 import logging
 import os
@@ -52,7 +54,7 @@ from aiohomematic.client import BaseRpcProxy
 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 _freeze_params, _unfreeze_params
+from aiohomematic.store.persistent import _cleanup_params_for_session, _freeze_params, _unfreeze_params
 from aiohomematic_test_support import const
 
 _LOGGER = logging.getLogger(__name__)
@@ -184,7 +186,7 @@ def get_client_session(  # noqa: C901
                         )
 
                 if method == _JsonRpcMethod.INTERFACE_SET_VALUE:
-                    await self._central.data_point_event(
+                    await self._central.event_coordinator.data_point_event(
                         interface_id=params[_JsonKey.INTERFACE],
                         channel_address=params[_JsonKey.ADDRESS],
                         parameter=params[_JsonKey.VALUE_KEY],
@@ -197,7 +199,7 @@ def get_client_session(  # noqa: C901
                         channel_address = params[_JsonKey.ADDRESS]
                         values = params[_JsonKey.SET]
                         for param, value in values.items():
-                            await self._central.data_point_event(
+                            await self._central.event_coordinator.data_point_event(
                                 interface_id=interface_id,
                                 channel_address=channel_address,
                                 parameter=param,
@@ -277,6 +279,9 @@ def get_xml_rpc_proxy(  # noqa: C901
             """Return the supported methods."""
             return self._supported_methods
 
+        def clear_connection_issue(self) -> None:
+            """Clear connection issue (no-op for test mock)."""
+
         async def clientServerInitialized(self, interface_id: str) -> None:
             """Answer clientServerInitialized with pong."""
             await self.ping(callerId=interface_id)
@@ -330,7 +335,7 @@ def get_xml_rpc_proxy(  # noqa: C901
         async def ping(self, callerId: str) -> None:
             """Answer ping with pong."""
             if self._central:
-                await self._central.data_point_event(
+                await self._central.event_coordinator.data_point_event(
                     interface_id=callerId,
                     channel_address="",
                     parameter=Parameter.PONG,
@@ -342,17 +347,17 @@ def get_xml_rpc_proxy(  # noqa: C901
         ) -> None:
             """Set a paramset."""
             if self._central and paramset_key == ParamsetKey.VALUES:
-                interface_id = self._central.primary_client.interface_id  # type: ignore[union-attr]
+                interface_id = self._central.client_coordinator.primary_client.interface_id  # type: ignore[union-attr]
                 for param, value in values.items():
-                    await self._central.data_point_event(
+                    await self._central.event_coordinator.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]
+                await self._central.event_coordinator.data_point_event(
+                    interface_id=self._central.client_coordinator.primary_client.interface_id,  # type: ignore[union-attr]
                     channel_address=channel_address,
                     parameter=parameter,
                     value=value,
@@ -376,25 +381,175 @@ def get_xml_rpc_proxy(  # noqa: C901
     return cast(BaseRpcProxy, _AioXmlRpcProxyFromSession())
 
 
+def _get_instance_attributes(instance: Any) -> set[str]:
+    """
+    Get all instance attribute names, supporting both __dict__ and __slots__.
+
+    For classes with __slots__, iterates through the class hierarchy to collect
+    all slot names. For classes with __dict__, returns the keys of __dict__.
+    Handles hybrid classes that have both __slots__ and __dict__.
+
+    Why this is needed:
+        Python classes can store instance attributes in two ways:
+        1. __dict__: A dictionary attached to each instance (default behavior)
+        2. __slots__: Pre-declared attribute names stored more efficiently
+
+        When copying attributes to a mock, we can't just use instance.__dict__
+        because __slots__-based classes don't have __dict__ (or have a limited one).
+        We must inspect the class hierarchy to find all declared slots.
+
+    Algorithm:
+        1. Walk the Method Resolution Order (MRO) to find all classes in hierarchy
+        2. For each class with __slots__, collect slot names (skip internal ones)
+        3. Verify each slot actually has a value on this instance (getattr check)
+        4. Also collect any __dict__ attributes if the instance has __dict__
+        5. Return the union of all found attribute names
+    """
+    attrs: set[str] = set()
+
+    # Walk the class hierarchy via MRO (Method Resolution Order).
+    # __slots__ are inherited but each class defines its own slots separately,
+    # so we must check every class in the hierarchy.
+    for cls in type(instance).__mro__:
+        if hasattr(cls, "__slots__"):
+            for slot in cls.__slots__:
+                # Skip internal slots like __dict__ and __weakref__ which are
+                # automatically added by Python when a class uses __slots__
+                if not slot.startswith("__"):
+                    try:
+                        # Only include if the attribute actually exists on the instance.
+                        # Slots can be declared but unset (raises AttributeError).
+                        getattr(instance, slot)
+                        attrs.add(slot)
+                    except AttributeError:
+                        # Slot is declared but not initialized on this instance
+                        pass
+
+    # Also include __dict__ attributes if the instance has __dict__.
+    # Some classes have both __slots__ and __dict__ (e.g., if a parent class
+    # doesn't use __slots__, or if __dict__ is explicitly in __slots__).
+    if hasattr(instance, "__dict__"):
+        attrs.update(instance.__dict__.keys())
+
+    return attrs
+
+
 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."""
+    """
+    Create a mock that wraps an instance with proper property delegation.
+
+    Supports both __dict__-based and __slots__-based classes. Properties are
+    delegated dynamically to the wrapped instance to ensure current values
+    are always returned.
+
+    Problem solved:
+        MagicMock(wraps=instance) only delegates method calls, not property access.
+        When you access mock.some_property, MagicMock returns the value that was
+        captured at mock creation time, not the current value on the wrapped instance.
+        This causes test failures when the wrapped instance's state changes after
+        the mock is created (e.g., client.available changes from False to True
+        after initialize_proxy() is called).
+
+    Solution:
+        Create a dynamic MagicMock subclass with property descriptors that delegate
+        to the wrapped instance on every access. This ensures properties always
+        return current values.
+
+    Algorithm:
+        1. If already a Mock, just sync attributes from wrapped instance
+        2. Identify all properties on the instance's class
+        3. Create a MagicMock subclass with delegating property descriptors
+        4. Create mock instance with spec and wraps
+        5. Copy instance attributes (supports both __slots__ and __dict__)
+        6. Copy non-mockable methods directly to mock
+    """
     if exclude_methods is None:
         exclude_methods = set()
     if include_properties is None:
         include_properties = set()
 
+    # Early return: if already a Mock, just refresh attributes from wrapped instance
     if isinstance(instance, Mock):
-        instance.__dict__.update(instance._mock_wraps.__dict__)
+        if hasattr(instance, "_mock_wraps") and instance._mock_wraps is not None:
+            for attr in _get_instance_attributes(instance._mock_wraps):
+                with contextlib.suppress(AttributeError, TypeError):
+                    setattr(instance, attr, getattr(instance._mock_wraps, attr))
         return instance
-    mock = MagicMock(spec=instance, wraps=instance, **kwargs)
-    mock.__dict__.update(instance.__dict__)
+
+    # Step 1: Identify all @property 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)
+
+    # Step 2: Create a dynamic MagicMock subclass
+    # We add property descriptors to this subclass that delegate to _mock_wraps.
+    # This is the key technique: property descriptors on the class take precedence
+    # over MagicMock's attribute access, allowing us to intercept property reads.
+    class _DynamicMock(MagicMock):
+        pass
+
+    # Helper factory functions to create closures with correct name binding.
+    # Using a factory function ensures each property gets its own 'name' variable,
+    # avoiding the classic lambda closure bug where all properties would share
+    # the last loop value.
+    def _make_getter(name: str) -> Callable[[Any], Any]:
+        """Create a getter that delegates to the wrapped instance."""
+
+        def getter(self: Any) -> Any:
+            # Access _mock_wraps which holds the original instance
+            return getattr(self._mock_wraps, name)
+
+        return getter
+
+    def _make_setter(name: str) -> Callable[[Any, Any], None]:
+        """Create a setter that delegates to the wrapped instance."""
+
+        def setter(self: Any, value: Any) -> None:
+            setattr(self._mock_wraps, name, value)
+
+        return setter
+
+    # Step 3: Add property descriptors to the dynamic subclass
+    for prop_name in property_names:
+        # Skip properties that should be mocked or overridden via kwargs
+        if prop_name not in include_properties and prop_name not in kwargs:
+            # Check if the original property has a setter (is writable)
+            prop_descriptor = getattr(type(instance), prop_name, None)
+            if prop_descriptor is not None and getattr(prop_descriptor, "fset", None) is not None:
+                # Writable property: create descriptor with both getter and setter
+                setattr(
+                    _DynamicMock,
+                    prop_name,
+                    property(_make_getter(prop_name), _make_setter(prop_name)),
+                )
+            else:
+                # Read-only property: create descriptor with getter only
+                setattr(
+                    _DynamicMock,
+                    prop_name,
+                    property(_make_getter(prop_name)),
+                )
+
+    # Step 4: Create the mock instance
+    # spec=instance: ensures mock only allows access to attributes that exist on instance
+    # wraps=instance: delegates method calls to the real instance
+    mock = _DynamicMock(spec=instance, wraps=instance, **kwargs)
+
+    # Step 5: Copy instance attributes to mock
+    # This handles both __slots__ and __dict__ based classes via _get_instance_attributes()
+    for attr in _get_instance_attributes(instance):
+        with contextlib.suppress(AttributeError, TypeError):
+            setattr(mock, attr, getattr(instance, attr))
+
+    # Step 6: Copy non-mockable methods directly
+    # Some methods (like bound methods or special attributes) need to be copied
+    # directly rather than being mocked
     try:
         for method_name in [
             prop
             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
+            if prop not in include_properties and prop not in kwargs and prop not in property_names
         ]:
             setattr(mock, method_name, getattr(instance, method_name))
     except Exception:
@@ -513,7 +668,7 @@ class SessionPlayer:
             return None
         if not (bucket_by_parameter := bucket_by_method.get(method)):
             return None
-        frozen_params = _freeze_params(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: