ucapi-framework 1.9.2__tar.gz → 1.9.3__tar.gz

{ucapi_framework-1.9.2 → ucapi_framework-1.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucapi-framework
-Version: 1.9.2
+Version: 1.9.3
 Summary: ucapi framework that provides core functionality for building integrations.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{ucapi_framework-1.9.2 → ucapi_framework-1.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ucapi-framework"
-version = "1.9.2"
+version = "1.9.3"
 description = "ucapi framework that provides core functionality for building integrations."
 readme = "README.md"
 requires-python = ">=3.11"

{ucapi_framework-1.9.2 → ucapi_framework-1.9.3}/tests/test_discovery.py

@@ -451,28 +451,87 @@ class TestMDNSDiscovery:
 
     @pytest.mark.asyncio
     async def test_discover_with_zeroconf(self):
-        """Test mDNS discovery with mocked zeroconf."""
+        """Test mDNS discovery with mocked zeroconf async classes."""
         mock_service_info = Mock()
         mock_service_info.name = "test-device._test._tcp.local."
         mock_service_info.server = "Test Device"
         mock_service_info.addresses = [b"\xc0\xa8\x01\x64"]  # 192.168.1.100 as bytes
         mock_service_info.port = 8080
 
-        mock_zeroconf = Mock()
-        mock_service_browser = Mock()
+        # ServiceListener must be a real class so Listener can inherit from it
+        class MockServiceListener:
+            pass
+
+        # Track the Listener instance created inside discover()
+        captured_listener: dict = {}
+
+        # Mock AsyncZeroconf
+        mock_aiozc = AsyncMock()
+        mock_aiozc.zeroconf = Mock()
+        mock_aiozc.async_get_service_info = AsyncMock(return_value=mock_service_info)
+        mock_aiozc.async_close = AsyncMock()
+
+        # Mock AsyncServiceBrowser – capture the listener so we can call add_service
+        def mock_browser_init(zc, service_type, listener):
+            captured_listener["obj"] = listener
+            browser = Mock()
+            browser.async_cancel = AsyncMock()
+            return browser
 
         mock_zeroconf_module = Mock()
-        mock_zeroconf_module.Zeroconf.return_value = mock_zeroconf
-        mock_zeroconf_module.ServiceBrowser.return_value = mock_service_browser
+        mock_zeroconf_module.ServiceListener = MockServiceListener
+
+        mock_asyncio_module = Mock()
+        mock_asyncio_module.AsyncZeroconf = Mock(return_value=mock_aiozc)
+        mock_asyncio_module.AsyncServiceBrowser = Mock(side_effect=mock_browser_init)
+
+        with (
+            patch.dict(
+                "sys.modules",
+                {
+                    "zeroconf": mock_zeroconf_module,
+                    "zeroconf.asyncio": mock_asyncio_module,
+                },
+            ),
+            patch("asyncio.sleep", new_callable=AsyncMock) as mock_sleep,
+        ):
+
+            async def trigger_discovery(*args, **kwargs):
+                listener = captured_listener.get("obj")
+                if listener:
+                    listener.add_service(
+                        mock_aiozc.zeroconf,
+                        "_test._tcp.local.",
+                        "test-device._test._tcp.local.",
+                    )
+
+            mock_sleep.side_effect = trigger_discovery
 
-        with patch.dict("sys.modules", {"zeroconf": mock_zeroconf_module}):
             discovery = ConcreteMDNSDiscovery(
                 service_type="_test._tcp.local.", timeout=1
             )
             devices = await discovery.discover()
 
-            # Due to asyncio sleep and mocking complexity, this is more of a structure test
-            assert isinstance(devices, list)
+            assert len(devices) == 1
+            assert devices[0].identifier == "test-device._test._tcp.local."
+            assert devices[0].name == "Test Device"
+            mock_aiozc.async_get_service_info.assert_called_once_with(
+                "_test._tcp.local.", "test-device._test._tcp.local."
+            )
+
+    @pytest.mark.asyncio
+    async def test_discover_handles_import_error(self):
+        """Test that discover handles missing zeroconf gracefully."""
+        discovery = ConcreteMDNSDiscovery(service_type="_test._tcp.local.", timeout=1)
+
+        def mock_import(name, *args, **kwargs):
+            if name in ("zeroconf", "zeroconf.asyncio"):
+                raise ImportError(f"No module named '{name}'")
+            return __import__(name, *args, **kwargs)
+
+        with patch("builtins.__import__", side_effect=mock_import):
+            devices = await discovery.discover()
+            assert devices == []
 
 
 class TestNetworkScanDiscovery:

{ucapi_framework-1.9.2 → ucapi_framework-1.9.3}/ucapi_framework/discovery.py

@@ -34,6 +34,7 @@ for integrations that don't use them. Install only what you need:
 :license: Mozilla Public License Version 2.0, see LICENSE for more details.
 """
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -356,40 +357,44 @@ class MDNSDiscovery(BaseDiscovery):
 
         try:
             try:
-                from zeroconf import ServiceBrowser, ServiceListener, Zeroconf  # type: ignore[import-not-found]
+                from zeroconf import ServiceListener  # type: ignore[import-not-found]
+                from zeroconf.asyncio import AsyncServiceBrowser, AsyncZeroconf
             except ImportError as err:
                 raise ImportError(
                     "zeroconf package is required for mDNS discovery. "
                     "Install it with: pip install zeroconf"
                 ) from err
 
-            import asyncio
-
-            zeroconf = Zeroconf()
-            discovered = []
+            discovered_names: list[tuple[str, str]] = []
 
             class Listener(ServiceListener):
-                def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:
-                    info = zc.get_service_info(type_, name)
-                    if info:
-                        discovered.append(info)
+                """Listener for mDNS service discovery events."""
 
-                def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:
-                    pass
+                def add_service(self, zc, type_: str, name: str) -> None:
+                    discovered_names.append((type_, name))
 
-                def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:
+                def remove_service(self, zc, type_: str, name: str) -> None:
                     pass
 
-            browser = ServiceBrowser(zeroconf, self.service_type, Listener())
-
-            # Wait for discovery timeout
-            await asyncio.sleep(self.timeout)
+                def update_service(self, zc, type_: str, name: str) -> None:
+                    pass
 
-            browser.cancel()
-            zeroconf.close()
+            aiozc = AsyncZeroconf()
+            try:
+                browser = AsyncServiceBrowser(
+                    aiozc.zeroconf, self.service_type, Listener()
+                )
+                await asyncio.sleep(self.timeout)
+                await browser.async_cancel()
+                discovered = [
+                    info
+                    for type_, name in discovered_names
+                    if (info := await aiozc.async_get_service_info(type_, name))
+                ]
+            finally:
+                await aiozc.async_close()
 
             self._discovered_devices.clear()
-
             for service_info in discovered:
                 device = self.parse_mdns_service(service_info)
                 if device:
@@ -399,10 +404,8 @@ class MDNSDiscovery(BaseDiscovery):
                 "mDNS discovery complete: found %d device(s)",
                 len(self._discovered_devices),
             )
-
         except Exception as err:  # pylint: disable=broad-exception-caught
             _LOG.error("mDNS discovery error: %s", err)
-
         return self._discovered_devices
 
     @abstractmethod

{ucapi_framework-1.9.2 → ucapi_framework-1.9.3}/ucapi_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ucapi-framework
-Version: 1.9.2
+Version: 1.9.3
 Summary: ucapi framework that provides core functionality for building integrations.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown