webex-message-handler 0.6.12__tar.gz → 0.6.14__tar.gz

{webex_message_handler-0.6.12 → webex_message_handler-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webex-message-handler
-Version: 0.6.12
+Version: 0.6.14
 Summary: Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages without the full Webex SDK
 Project-URL: Homepage, https://github.com/3rg0n/webex-message-handler
 Project-URL: Repository, https://github.com/3rg0n/webex-message-handler
@@ -33,6 +33,8 @@ Description-Content-Type: text/markdown
 
 Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages — no Webex SDK required.
 
+📖 **[Documentation & overview →](https://3rg0n.github.io/webex-message-handler/)**
+
 Python port of the [TypeScript webex-message-handler](https://github.com/ecopelan/webex-message-handler).
 
 ## Why?
@@ -186,6 +188,15 @@ async def on_message(msg):
 
 Resource types: `"MESSAGE"`, `"PEOPLE"`, `"ROOM"`.
 
+## Region Discovery
+
+Webex assigns each org to a service region (e.g. `wdm-a`, `wdm-r`). On connect,
+the library discovers your org's correct WDM endpoint from the Webex U2C service
+catalog and registers there automatically — no configuration needed. Registering
+in the wrong region produces a socket that authorizes and completes the KMS
+handshake but never receives that org's messages, so this is done for you. If
+discovery fails for any reason, it falls back to the default region.
+
 ## Delivery Guarantees
 
 This library provides **at-most-once** delivery semantics:

{webex_message_handler-0.6.12 → webex_message_handler-0.6.14}/README.md

@@ -2,6 +2,8 @@
 
 Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages — no Webex SDK required.
 
+📖 **[Documentation & overview →](https://3rg0n.github.io/webex-message-handler/)**
+
 Python port of the [TypeScript webex-message-handler](https://github.com/ecopelan/webex-message-handler).
 
 ## Why?
@@ -155,6 +157,15 @@ async def on_message(msg):
 
 Resource types: `"MESSAGE"`, `"PEOPLE"`, `"ROOM"`.
 
+## Region Discovery
+
+Webex assigns each org to a service region (e.g. `wdm-a`, `wdm-r`). On connect,
+the library discovers your org's correct WDM endpoint from the Webex U2C service
+catalog and registers there automatically — no configuration needed. Registering
+in the wrong region produces a socket that authorizes and completes the KMS
+handshake but never receives that org's messages, so this is done for you. If
+discovery fails for any reason, it falls back to the default region.
+
 ## Delivery Guarantees
 
 This library provides **at-most-once** delivery semantics:

{webex_message_handler-0.6.12 → webex_message_handler-0.6.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "webex-message-handler"
-version = "0.6.12"
+version = "0.6.14"
 description = "Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages without the full Webex SDK"
 readme = "README.md"
 license = "MIT"

webex_message_handler-0.6.14/src/webex_message_handler/device_manager.py

@@ -0,0 +1,345 @@
+"""WDM device registration, refresh, and unregistration."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .errors import AuthError, DeviceRegistrationError
+from .logger import Logger, noop_logger
+from .types import DeviceRegistration, FetchFunction, FetchRequest
+from .url_validation import validate_webex_url
+
+WDM_API_BASE = "https://wdm-a.wbx2.com/wdm/api/v1/devices"
+U2C_CATALOG_URL = "https://u2c.wbx2.com/u2c/api/v1/catalog?format=hostmap"
+
+_DEVICE_BODY = {
+    "deviceName": "webex-message-handler",
+    "deviceType": "DESKTOP",
+    "localizedModel": "python",
+    "model": "python",
+    "name": "webex-message-handler",
+    "systemName": "webex-message-handler",
+    "systemVersion": "1.0.0",
+}
+
+
+class DeviceManager:
+    """Manages WDM device registration lifecycle."""
+
+    def __init__(
+        self,
+        *,
+        logger: Logger | None = None,
+        http_do: FetchFunction,
+    ) -> None:
+        self._logger: Logger = logger or noop_logger  # type: ignore[assignment]
+        self._http_do = http_do
+        self._device_url: str | None = None
+        self._wdm_devices_url: str | None = None
+
+    async def _discover_wdm_base(self, token: str) -> str:
+        """Discover the org-assigned WDM devices endpoint from U2C.
+
+        Caches the result. On any failure falls back to the hard-coded WDM_API_BASE
+        (never fatal), so a U2C outage degrades to today's behavior.
+        """
+        if self._wdm_devices_url:
+            return self._wdm_devices_url
+
+        try:
+            response = await self._http_do(
+                FetchRequest(
+                    url=U2C_CATALOG_URL,
+                    method="GET",
+                    headers={"Authorization": f"Bearer {token}"},
+                )
+            )
+
+            if not response.ok:
+                self._logger.warning(
+                    f"U2C discovery returned {response.status}; falling back to {WDM_API_BASE}"
+                )
+                self._wdm_devices_url = WDM_API_BASE
+                return self._wdm_devices_url
+
+            catalog = await response.json()
+            wdm = catalog.get("serviceLinks", {}).get("wdm")
+
+            if not wdm:
+                self._logger.warning(
+                    f"U2C catalog has no wdm service link; falling back to {WDM_API_BASE}"
+                )
+                self._wdm_devices_url = WDM_API_BASE
+                return self._wdm_devices_url
+
+            try:
+                validate_webex_url(wdm, "https")
+            except ValueError as exc:
+                self._logger.error(
+                    f'U2C-discovered wdm URL "{wdm}" untrusted ({exc}); falling back to {WDM_API_BASE}'
+                )
+                self._wdm_devices_url = WDM_API_BASE
+                return self._wdm_devices_url
+
+            self._wdm_devices_url = wdm.rstrip("/") + "/devices"
+            self._logger.info(f"Discovered region-correct WDM endpoint: {self._wdm_devices_url}")
+            return self._wdm_devices_url
+
+        except Exception as exc:
+            self._logger.warning(
+                f"U2C discovery failed ({exc}); falling back to {WDM_API_BASE}"
+            )
+            self._wdm_devices_url = WDM_API_BASE
+            return self._wdm_devices_url
+
+    def set_wdm_devices_url(self, url: str) -> None:
+        """Pre-seed the discovered WDM devices endpoint (test helper)."""
+        self._wdm_devices_url = url
+
+    async def register(self, token: str) -> DeviceRegistration:
+        """Register a new device with WDM.
+
+        To avoid leaking a new device on every Connect() (which eventually trips the
+        Webex per-user device cap → HTTP 403), it first lists existing devices and
+        reuses/refreshes one matching this client's name+deviceType. Only when no
+        reusable device exists does it POST a new one. If registration fails because
+        the account already has excessive registrations, it reaps this client's own
+        devices and retries once.
+        """
+        self._logger.debug("Registering device with WDM")
+
+        # Reuse-before-register: if a device of ours already exists, refresh it.
+        existing_url = await self._find_reusable_device(token)
+        if existing_url:
+            self._device_url = existing_url
+            try:
+                reg = await self.refresh(token)
+                self._logger.info("Reused existing WDM device registration")
+                return reg
+            except Exception:
+                # Refresh failed (device stale/deleted server-side) — fall through to
+                # create a fresh one.
+                self._device_url = None
+
+        try:
+            reg = await self._create_device(token)
+        except DeviceRegistrationError as exc:
+            if self._is_excessive_registrations_error(exc):
+                msg = "Excessive device registrations detected — reaping this client's devices and retrying"
+                self._logger.warning(msg)
+                await self._reap_own_devices(token)
+                return await self._create_device(token)
+            raise
+        return reg
+
+    async def _create_device(self, token: str) -> DeviceRegistration:
+        """Perform the raw POST /devices registration."""
+        try:
+            base = await self._discover_wdm_base(token)
+            create_url = f"{base}?includeUpstreamServices=all"
+            response = await self._http_do(
+                FetchRequest(
+                    url=create_url,
+                    method="POST",
+                    headers={
+                        "Authorization": f"Bearer {token}",
+                        "Content-Type": "application/json",
+                    },
+                    body=json.dumps(_DEVICE_BODY),
+                )
+            )
+
+            if response.status == 401:
+                self._logger.error("Device registration failed: Unauthorized")
+                raise AuthError("Unauthorized to register device")
+
+            if not response.ok:
+                self._logger.error(f"Device registration failed with status {response.status}")
+                raise DeviceRegistrationError("Failed to register device", response.status)
+
+            data = await response.json()
+            self._device_url = data["url"]
+            registration = self._parse_device_response(data)
+            self._logger.info("Device registered successfully")
+            return registration
+
+        except (AuthError, DeviceRegistrationError):
+            raise
+        except Exception as exc:
+            self._logger.error(f"Device registration error: {exc}")
+            raise DeviceRegistrationError("Failed to register device") from exc
+
+    async def _find_reusable_device(self, token: str) -> str | None:
+        """List existing WDM devices and return the URL of one matching this
+        client's name+deviceType, or None if none/on any error (in which case the
+        caller falls back to creating a new device — best-effort, never fatal).
+        """
+        try:
+            devices = await self._list_devices(token)
+            for device in devices:
+                device_data: dict[str, Any] = device if isinstance(device, dict) else device.__dict__
+                if (
+                    device_data.get("name") == _DEVICE_BODY["name"]
+                    and device_data.get("deviceType") == _DEVICE_BODY["deviceType"]
+                    and device_data.get("url")
+                ):
+                    return device_data["url"]
+        except Exception as exc:
+            self._logger.debug(f"Could not list existing devices (will create new): {exc}")
+        return None
+
+    async def _reap_own_devices(self, token: str) -> None:
+        """Best-effort deletes all WDM devices matching this client's
+        name+deviceType, to recover from the per-user device cap. Never fatal.
+        """
+        try:
+            devices = await self._list_devices(token)
+            reaped = 0
+            for device in devices:
+                device_data: dict[str, Any] = device if isinstance(device, dict) else device.__dict__
+                if (
+                    device_data.get("name") != _DEVICE_BODY["name"]
+                    or device_data.get("deviceType") != _DEVICE_BODY["deviceType"]
+                    or not device_data.get("url")
+                ):
+                    continue
+                try:
+                    resp = await self._http_do(
+                        FetchRequest(
+                            url=device_data["url"],
+                            method="DELETE",
+                            headers={"Authorization": f"Bearer {token}"},
+                        )
+                    )
+                    if resp.ok or resp.status == 404:
+                        reaped += 1
+                except Exception as exc:
+                    self._logger.debug(f"Failed to reap device {device_data.get('url')}: {exc}")
+            self._logger.info(f"Reaped {reaped} stale WDM device(s)")
+        except Exception as exc:
+            self._logger.warning(f"Could not list devices to reap: {exc}")
+
+    async def _list_devices(self, token: str) -> list[Any]:
+        """Fetches the account's current WDM device registrations from the region-correct endpoint."""
+        base = await self._discover_wdm_base(token)
+        response = await self._http_do(
+            FetchRequest(
+                url=base,
+                method="GET",
+                headers={"Authorization": f"Bearer {token}"},
+            )
+        )
+
+        if response.status == 401:
+            raise AuthError("Unauthorized to list devices")
+
+        if not response.ok:
+            raise DeviceRegistrationError(
+                f"Failed to list devices: {response.status}",
+                response.status,
+            )
+
+        data = await response.json()
+        return data.get("devices", [])
+
+    @staticmethod
+    def _is_excessive_registrations_error(error: Exception) -> bool:
+        """Report whether error is the WDM per-user device cap rejection (HTTP 403)."""
+        return isinstance(error, DeviceRegistrationError) and error.status_code == 403
+
+    async def refresh(self, token: str) -> DeviceRegistration:
+        """Refresh an existing device registration."""
+        if not self._device_url:
+            raise DeviceRegistrationError("Device not registered. Call register() first.")
+
+        self._logger.debug("Refreshing device registration")
+
+        try:
+            response = await self._http_do(
+                FetchRequest(
+                    url=self._device_url,
+                    method="PUT",
+                    headers={
+                        "Authorization": f"Bearer {token}",
+                        "Content-Type": "application/json",
+                    },
+                    body=json.dumps(_DEVICE_BODY),
+                )
+            )
+
+            if response.status == 401:
+                self._logger.error("Device refresh failed: Unauthorized")
+                raise AuthError("Unauthorized to refresh device")
+
+            if not response.ok:
+                self._logger.error(f"Device refresh failed with status {response.status}")
+                raise DeviceRegistrationError("Failed to refresh device", response.status)
+
+            data = await response.json()
+            registration = self._parse_device_response(data)
+            self._logger.info("Device refreshed successfully")
+            return registration
+
+        except (AuthError, DeviceRegistrationError):
+            raise
+        except Exception as exc:
+            self._logger.error(f"Device refresh error: {exc}")
+            raise DeviceRegistrationError("Failed to refresh device") from exc
+
+    async def unregister(self, token: str) -> None:
+        """Unregister the device from WDM."""
+        if not self._device_url:
+            raise DeviceRegistrationError("Device not registered. Call register() first.")
+
+        self._logger.debug("Unregistering device")
+
+        try:
+            response = await self._http_do(
+                FetchRequest(
+                    url=self._device_url,
+                    method="DELETE",
+                    headers={
+                        "Authorization": f"Bearer {token}",
+                        "Content-Type": "application/json",
+                    },
+                )
+            )
+
+            if response.status == 401:
+                self._logger.error("Device unregistration failed: Unauthorized")
+                raise AuthError("Unauthorized to unregister device")
+
+            if not response.ok:
+                self._logger.error(f"Device unregistration failed with status {response.status}")
+                raise DeviceRegistrationError("Failed to unregister device", response.status)
+
+            self._device_url = None
+            self._logger.info("Device unregistered successfully")
+
+        except (AuthError, DeviceRegistrationError):
+            raise
+        except Exception as exc:
+            self._logger.error(f"Device unregistration error: {exc}")
+            raise DeviceRegistrationError("Failed to unregister device") from exc
+
+    def _parse_device_response(self, data: dict[str, Any]) -> DeviceRegistration:
+        services: dict[str, str] = data.get("services", {})
+        if not isinstance(services, dict):
+            services = {}
+
+        web_socket_url = data["webSocketUrl"]
+        encryption_service_url = services.get("encryptionServiceUrl", "")
+
+        # Validate URLs from external API response
+        validate_webex_url(web_socket_url, "wss")
+        if encryption_service_url:
+            validate_webex_url(encryption_service_url, "https")
+
+        return DeviceRegistration(
+            web_socket_url=web_socket_url,
+            device_url=data["url"],
+            user_id=data["userId"],
+            services=services,
+            encryption_service_url=encryption_service_url,
+        )

{webex_message_handler-0.6.12 → webex_message_handler-0.6.14}/src/webex_message_handler/mention_parser.py

@@ -14,9 +14,12 @@ class ParsedMentions:
     mentioned_groups: list[str] = field(default_factory=list)
 
 
-_MENTION_RE = re.compile(
-    r'<spark-mention[^>]*data-object-type="([^"]*)"[^>]*>', re.IGNORECASE
-)
+# Match the whole opening tag with a single bounded ``[^>]*`` (linear), then
+# pull attributes out of the captured tag. A prior form used two ``[^>]*``
+# around the attribute, which is a polynomial-ReDoS risk under Python's
+# backtracking ``re`` engine on crafted ``<spark-mention…`` input.
+_MENTION_RE = re.compile(r"<spark-mention[^>]*>", re.IGNORECASE)
+_OBJECT_TYPE_RE = re.compile(r'data-object-type="([^"]*)"', re.IGNORECASE)
 _PERSON_ID_RE = re.compile(r'data-object-id="([^"]*)"', re.IGNORECASE)
 _GROUP_TYPE_RE = re.compile(r'data-group-type="([^"]*)"', re.IGNORECASE)
 
@@ -41,7 +44,8 @@ def parse_mentions(html: str | None) -> ParsedMentions:
 
     for match in _MENTION_RE.finditer(html):
         tag = match.group(0)
-        object_type = match.group(1)
+        type_match = _OBJECT_TYPE_RE.search(tag)
+        object_type = type_match.group(1) if type_match else ""
 
         if object_type == "person":
             id_match = _PERSON_ID_RE.search(tag)

webex_message_handler-0.6.14/tests/test_device_manager.py

@@ -0,0 +1,406 @@
+"""Tests for DeviceManager."""
+
+import pytest
+
+from tests.conftest import MockHttpDo
+from webex_message_handler.device_manager import U2C_CATALOG_URL, WDM_API_BASE, DeviceManager
+from webex_message_handler.errors import AuthError, DeviceRegistrationError
+
+MOCK_TOKEN = "test-token"
+MOCK_DEVICE_URL = "https://wdm-a.wbx2.com/wdm/api/v1/devices/test-device-id"
+MOCK_WS_URL = "wss://mercury.example.com/socket"
+MOCK_USER_ID = "user-123"
+
+MOCK_WDM_RESPONSE = {
+    "webSocketUrl": MOCK_WS_URL,
+    "url": MOCK_DEVICE_URL,
+    "userId": MOCK_USER_ID,
+    "services": {
+        "encryptionServiceUrl": "https://encryption.example.com",
+        "messenger": "https://messenger.example.com",
+    },
+}
+
+
+class TestRegister:
+    async def test_successful_registration(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.web_socket_url == MOCK_WS_URL
+        assert result.device_url == MOCK_DEVICE_URL
+        assert result.user_id == MOCK_USER_ID
+        assert result.encryption_service_url == "https://encryption.example.com"
+        assert result.services["messenger"] == "https://messenger.example.com"
+
+    async def test_auth_error_on_401(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", status=401)  # create fails with 401
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        with pytest.raises(AuthError):
+            await dm.register(MOCK_TOKEN)
+
+    async def test_device_registration_error_on_non_2xx(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", status=400)  # create fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        with pytest.raises(DeviceRegistrationError, match="Failed to register device"):
+            await dm.register(MOCK_TOKEN)
+
+    async def test_device_registration_error_on_network_failure(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add(
+                "POST",
+                f"{WDM_API_BASE}?includeUpstreamServices=all",
+                exc=ConnectionError("Network error"),
+            )  # create fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.register(MOCK_TOKEN)
+
+
+class TestRefresh:
+    async def test_successful_refresh(self):
+        refreshed = {**MOCK_WDM_RESPONSE, "webSocketUrl": "wss://mercury-new.example.com/socket"}
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("PUT", MOCK_DEVICE_URL, payload=refreshed)  # refresh
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        result = await dm.refresh(MOCK_TOKEN)
+
+        assert result.web_socket_url == "wss://mercury-new.example.com/socket"
+
+    async def test_error_if_not_registered(self):
+        http_do = MockHttpDo()
+        dm = DeviceManager(http_do=http_do)
+        with pytest.raises(DeviceRegistrationError, match="Device not registered"):
+            await dm.refresh(MOCK_TOKEN)
+
+    async def test_auth_error_on_401_during_refresh(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("PUT", MOCK_DEVICE_URL, status=401)  # refresh fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(AuthError):
+            await dm.refresh(MOCK_TOKEN)
+
+    async def test_device_registration_error_on_refresh_failure(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("PUT", MOCK_DEVICE_URL, status=500)  # refresh fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.refresh(MOCK_TOKEN)
+
+
+class TestUnregister:
+    async def test_successful_unregister(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("DELETE", MOCK_DEVICE_URL, status=204)  # unregister
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        await dm.unregister(MOCK_TOKEN)
+
+    async def test_error_if_not_registered(self):
+        http_do = MockHttpDo()
+        dm = DeviceManager(http_do=http_do)
+        with pytest.raises(DeviceRegistrationError, match="Device not registered"):
+            await dm.unregister(MOCK_TOKEN)
+
+    async def test_auth_error_on_401_during_unregister(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("DELETE", MOCK_DEVICE_URL, status=401)  # unregister fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(AuthError):
+            await dm.unregister(MOCK_TOKEN)
+
+    async def test_device_registration_error_on_unregister_failure(self):
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+            .add("DELETE", MOCK_DEVICE_URL, status=500)  # unregister fails
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.unregister(MOCK_TOKEN)
+
+
+class TestServiceParsing:
+    async def test_empty_services(self):
+        response = {**MOCK_WDM_RESPONSE, "services": {}}
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=response)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.services == {}
+        assert result.encryption_service_url == ""
+
+    async def test_missing_encryption_service_url(self):
+        response = {**MOCK_WDM_RESPONSE, "services": {"messenger": "https://messenger.example.com"}}
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=response)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert "messenger" in result.services
+        assert result.encryption_service_url == ""
+
+
+class TestDeviceReuseAndReaping:
+    async def test_reuses_existing_device_and_calls_refresh_instead_of_create(self):
+        """Verify that when a device matching name+deviceType already exists,
+        Register refreshes it (PUT) instead of creating a new one (POST).
+        """
+        http_do = (
+            MockHttpDo()
+            .add(
+                "GET",
+                WDM_API_BASE,
+                payload={
+                    "devices": [
+                        {
+                            "webSocketUrl": MOCK_WS_URL,
+                            "url": MOCK_DEVICE_URL,
+                            "userId": MOCK_USER_ID,
+                            "name": "webex-message-handler",
+                            "deviceType": "DESKTOP",
+                            "services": {},
+                        }
+                    ]
+                },
+            )
+            .add("PUT", MOCK_DEVICE_URL, payload=MOCK_WDM_RESPONSE)
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        # Should be: GET (list) + PUT (refresh)
+        assert len(http_do.calls) == 2
+        assert http_do.calls[0].method == "GET"
+        assert http_do.calls[1].method == "PUT"
+
+    async def test_reaps_devices_on_403_and_retries_create(self):
+        """Verify that a 403 on create triggers reaping of this client's own
+        devices followed by a single retry.
+        """
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # reuse check: empty
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", status=403)  # first POST fails
+            .add(
+                "GET",
+                WDM_API_BASE,
+                payload={
+                    "devices": [
+                        {
+                            "url": f"{MOCK_DEVICE_URL}/old",
+                            "name": "webex-message-handler",
+                            "deviceType": "DESKTOP",
+                        }
+                    ]
+                },
+            )  # reap: return device to delete
+            .add("DELETE", f"{MOCK_DEVICE_URL}/old", status=204)  # delete old device
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # retry POST
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        # Should be: GET (reuse) + POST (403) + GET (reap) + DELETE + POST (retry)
+        assert len(http_do.calls) == 5
+        assert http_do.calls[0].method == "GET"
+        assert http_do.calls[1].method == "POST"
+        assert http_do.calls[2].method == "GET"
+        assert http_do.calls[3].method == "DELETE"
+        assert http_do.calls[4].method == "POST"
+
+    async def test_falls_back_to_create_when_list_fails(self):
+        """Verify that when list fails, register falls back to create."""
+        http_do = (
+            MockHttpDo()
+            .add("GET", WDM_API_BASE, status=500)  # list fails
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create succeeds
+        )
+        dm = DeviceManager(http_do=http_do)
+        dm.set_wdm_devices_url(WDM_API_BASE)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        # Should be: GET (list fails) + POST (create succeeds)
+        assert len(http_do.calls) == 2
+
+
+class TestU2CRegionDiscovery:
+    """Tests for U2C region discovery (#27)."""
+
+    async def test_discovers_region_correct_wdm_endpoint_from_u2c(self):
+        """Verify that register resolves the org-assigned WDM region from U2C."""
+        u2c_catalog = {"serviceLinks": {"wdm": "https://wdm-r.wbx2.com/wdm/api/v1"}}
+        regional_device_url = "https://wdm-r.wbx2.com/wdm/api/v1/devices/test-device-id"
+        regional_response = {**MOCK_WDM_RESPONSE, "url": regional_device_url}
+
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, payload=u2c_catalog)  # U2C discovery
+            .add("GET", "https://wdm-r.wbx2.com/wdm/api/v1/devices", payload={"devices": []})  # list
+            .add(
+                "POST",
+                "https://wdm-r.wbx2.com/wdm/api/v1/devices?includeUpstreamServices=all",
+                payload=regional_response,
+            )  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == regional_device_url
+        # Verify POST went to discovered regional endpoint, not hardcoded wdm-a
+        post_calls = [c for c in http_do.calls if c.method == "POST"]
+        assert "wdm-r.wbx2.com" in post_calls[0].url
+
+    async def test_caches_discovered_wdm_endpoint(self):
+        """Verify that the discovered WDM endpoint is cached."""
+        u2c_catalog = {"serviceLinks": {"wdm": "https://wdm-r.wbx2.com/wdm/api/v1"}}
+
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, payload=u2c_catalog)  # U2C discovery (first call)
+            .add("GET", "https://wdm-r.wbx2.com/wdm/api/v1/devices", payload={"devices": []})  # list
+            .add(
+                "POST",
+                "https://wdm-r.wbx2.com/wdm/api/v1/devices?includeUpstreamServices=all",
+                payload={**MOCK_WDM_RESPONSE, "url": "https://wdm-r.wbx2.com/wdm/api/v1/devices/id1"},
+            )  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+
+        # Register once; U2C should be called
+        await dm.register(MOCK_TOKEN)
+        u2c_calls = [c for c in http_do.calls if "u2c.wbx2.com" in c.url]
+        assert len(u2c_calls) == 1
+
+        # Pre-seed the cache
+        dm.set_wdm_devices_url("https://wdm-r.wbx2.com/wdm/api/v1/devices")
+        # Verify cache doesn't trigger another U2C call (would fail with assertion)
+
+    async def test_falls_back_to_wdm_a_when_u2c_returns_non_2xx(self):
+        """Verify discovery is best-effort: non-2xx U2C falls back to wdm-a."""
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, status=500)  # U2C discovery fails
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # list uses fallback
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        # Verify POST went to fallback wdm-a
+        post_calls = [c for c in http_do.calls if c.method == "POST"]
+        assert "wdm-a.wbx2.com" in post_calls[0].url
+
+    async def test_falls_back_to_wdm_a_when_u2c_has_no_wdm_link(self):
+        """Verify that missing wdm link in U2C response falls back to wdm-a."""
+        u2c_catalog = {"serviceLinks": {}}  # Missing wdm link
+
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, payload=u2c_catalog)  # U2C discovery
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # list uses fallback
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        post_calls = [c for c in http_do.calls if c.method == "POST"]
+        assert "wdm-a.wbx2.com" in post_calls[0].url
+
+    async def test_rejects_untrusted_wdm_host_from_u2c_and_falls_back(self):
+        """Verify that non-Webex wdm link from U2C is rejected and falls back."""
+        u2c_catalog = {"serviceLinks": {"wdm": "https://evil.attacker.com/wdm/api/v1"}}
+
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, payload=u2c_catalog)  # U2C discovery
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # list uses fallback
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        post_calls = [c for c in http_do.calls if c.method == "POST"]
+        assert "wdm-a.wbx2.com" in post_calls[0].url
+
+    async def test_falls_back_to_wdm_a_on_u2c_fetch_error(self):
+        """Verify that U2C fetch errors fall back to wdm-a."""
+        http_do = (
+            MockHttpDo()
+            .add("GET", U2C_CATALOG_URL, exc=ConnectionError("Network error"))  # U2C discovery fails
+            .add("GET", WDM_API_BASE, payload={"devices": []})  # list uses fallback
+            .add("POST", f"{WDM_API_BASE}?includeUpstreamServices=all", payload=MOCK_WDM_RESPONSE)  # create
+        )
+        dm = DeviceManager(http_do=http_do)
+        result = await dm.register(MOCK_TOKEN)
+
+        assert result.device_url == MOCK_DEVICE_URL
+        post_calls = [c for c in http_do.calls if c.method == "POST"]
+        assert "wdm-a.wbx2.com" in post_calls[0].url

webex_message_handler-0.6.14/tests/test_mention_parser.py

@@ -0,0 +1,62 @@
+"""Tests for the mention parser, including a ReDoS regression guard."""
+
+import time
+
+from webex_message_handler.mention_parser import parse_mentions
+
+
+def test_empty_inputs():
+    for v in (None, ""):
+        r = parse_mentions(v)
+        assert r.mentioned_people == []
+        assert r.mentioned_groups == []
+
+
+def test_single_person_mention():
+    html = '<spark-mention data-object-type="person" data-object-id="uuid-1">Alice</spark-mention>'
+    r = parse_mentions(html)
+    assert r.mentioned_people == ["uuid-1"]
+    assert r.mentioned_groups == []
+
+
+def test_multiple_person_mentions_dedup():
+    html = (
+        '<spark-mention data-object-type="person" data-object-id="uuid-1">A</spark-mention>'
+        '<spark-mention data-object-type="person" data-object-id="uuid-2">B</spark-mention>'
+        '<spark-mention data-object-type="person" data-object-id="uuid-1">A</spark-mention>'
+    )
+    assert parse_mentions(html).mentioned_people == ["uuid-1", "uuid-2"]
+
+
+def test_group_mention():
+    html = '<spark-mention data-object-type="groupMention" data-group-type="all">All</spark-mention>'
+    r = parse_mentions(html)
+    assert r.mentioned_people == []
+    assert r.mentioned_groups == ["all"]
+
+
+def test_attribute_order_independent():
+    html = (
+        '<spark-mention data-object-id="uuid-9" data-object-type="person">X</spark-mention>'
+        '<spark-mention data-group-type="all" data-object-type="groupMention">All</spark-mention>'
+    )
+    r = parse_mentions(html)
+    assert r.mentioned_people == ["uuid-9"]
+    assert r.mentioned_groups == ["all"]
+
+
+def test_ignores_non_mention_html():
+    r = parse_mentions("<p>hello <b>world</b></p>")
+    assert r.mentioned_people == []
+    assert r.mentioned_groups == []
+
+
+def test_no_polynomial_backtracking_redos_guard():
+    """Crafted input that made the old two-[^>]* regex backtrack must parse fast."""
+    evil = "<spark-mention" + ' data-object-type="' * 50000
+    start = time.monotonic()
+    r = parse_mentions(evil)
+    elapsed = time.monotonic() - start
+    assert r.mentioned_people == []
+    assert r.mentioned_groups == []
+    assert elapsed < 1.0

webex_message_handler-0.6.12/src/webex_message_handler/device_manager.py

@@ -1,170 +0,0 @@
-"""WDM device registration, refresh, and unregistration."""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from .errors import AuthError, DeviceRegistrationError
-from .logger import Logger, noop_logger
-from .types import DeviceRegistration, FetchFunction, FetchRequest
-from .url_validation import validate_webex_url
-
-WDM_API_BASE = "https://wdm-a.wbx2.com/wdm/api/v1/devices"
-
-_DEVICE_BODY = {
-    "deviceName": "webex-message-handler",
-    "deviceType": "DESKTOP",
-    "localizedModel": "python",
-    "model": "python",
-    "name": "webex-message-handler",
-    "systemName": "webex-message-handler",
-    "systemVersion": "1.0.0",
-}
-
-
-class DeviceManager:
-    """Manages WDM device registration lifecycle."""
-
-    def __init__(
-        self,
-        *,
-        logger: Logger | None = None,
-        http_do: FetchFunction,
-    ) -> None:
-        self._logger: Logger = logger or noop_logger  # type: ignore[assignment]
-        self._http_do = http_do
-        self._device_url: str | None = None
-
-    async def register(self, token: str) -> DeviceRegistration:
-        """Register a new device with WDM."""
-        self._logger.debug("Registering device with WDM")
-
-        try:
-            response = await self._http_do(
-                FetchRequest(
-                    url=WDM_API_BASE,
-                    method="POST",
-                    headers={
-                        "Authorization": f"Bearer {token}",
-                        "Content-Type": "application/json",
-                    },
-                    body=json.dumps(_DEVICE_BODY),
-                )
-            )
-
-            if response.status == 401:
-                self._logger.error("Device registration failed: Unauthorized")
-                raise AuthError("Unauthorized to register device")
-
-            if not response.ok:
-                self._logger.error(f"Device registration failed with status {response.status}")
-                raise DeviceRegistrationError("Failed to register device", response.status)
-
-            data = await response.json()
-            self._device_url = data["url"]
-            registration = self._parse_device_response(data)
-            self._logger.info("Device registered successfully")
-            return registration
-
-        except (AuthError, DeviceRegistrationError):
-            raise
-        except Exception as exc:
-            self._logger.error(f"Device registration error: {exc}")
-            raise DeviceRegistrationError("Failed to register device") from exc
-
-    async def refresh(self, token: str) -> DeviceRegistration:
-        """Refresh an existing device registration."""
-        if not self._device_url:
-            raise DeviceRegistrationError("Device not registered. Call register() first.")
-
-        self._logger.debug("Refreshing device registration")
-
-        try:
-            response = await self._http_do(
-                FetchRequest(
-                    url=self._device_url,
-                    method="PUT",
-                    headers={
-                        "Authorization": f"Bearer {token}",
-                        "Content-Type": "application/json",
-                    },
-                    body=json.dumps(_DEVICE_BODY),
-                )
-            )
-
-            if response.status == 401:
-                self._logger.error("Device refresh failed: Unauthorized")
-                raise AuthError("Unauthorized to refresh device")
-
-            if not response.ok:
-                self._logger.error(f"Device refresh failed with status {response.status}")
-                raise DeviceRegistrationError("Failed to refresh device", response.status)
-
-            data = await response.json()
-            registration = self._parse_device_response(data)
-            self._logger.info("Device refreshed successfully")
-            return registration
-
-        except (AuthError, DeviceRegistrationError):
-            raise
-        except Exception as exc:
-            self._logger.error(f"Device refresh error: {exc}")
-            raise DeviceRegistrationError("Failed to refresh device") from exc
-
-    async def unregister(self, token: str) -> None:
-        """Unregister the device from WDM."""
-        if not self._device_url:
-            raise DeviceRegistrationError("Device not registered. Call register() first.")
-
-        self._logger.debug("Unregistering device")
-
-        try:
-            response = await self._http_do(
-                FetchRequest(
-                    url=self._device_url,
-                    method="DELETE",
-                    headers={
-                        "Authorization": f"Bearer {token}",
-                        "Content-Type": "application/json",
-                    },
-                )
-            )
-
-            if response.status == 401:
-                self._logger.error("Device unregistration failed: Unauthorized")
-                raise AuthError("Unauthorized to unregister device")
-
-            if not response.ok:
-                self._logger.error(f"Device unregistration failed with status {response.status}")
-                raise DeviceRegistrationError("Failed to unregister device", response.status)
-
-            self._device_url = None
-            self._logger.info("Device unregistered successfully")
-
-        except (AuthError, DeviceRegistrationError):
-            raise
-        except Exception as exc:
-            self._logger.error(f"Device unregistration error: {exc}")
-            raise DeviceRegistrationError("Failed to unregister device") from exc
-
-    def _parse_device_response(self, data: dict[str, Any]) -> DeviceRegistration:
-        services: dict[str, str] = data.get("services", {})
-        if not isinstance(services, dict):
-            services = {}
-
-        web_socket_url = data["webSocketUrl"]
-        encryption_service_url = services.get("encryptionServiceUrl", "")
-
-        # Validate URLs from external API response
-        validate_webex_url(web_socket_url, "wss")
-        if encryption_service_url:
-            validate_webex_url(encryption_service_url, "https")
-
-        return DeviceRegistration(
-            web_socket_url=web_socket_url,
-            device_url=data["url"],
-            user_id=data["userId"],
-            services=services,
-            encryption_service_url=encryption_service_url,
-        )

webex_message_handler-0.6.12/tests/test_device_manager.py

@@ -1,156 +0,0 @@
-"""Tests for DeviceManager."""
-
-import pytest
-
-from tests.conftest import MockHttpDo
-from webex_message_handler.device_manager import WDM_API_BASE, DeviceManager
-from webex_message_handler.errors import AuthError, DeviceRegistrationError
-
-MOCK_TOKEN = "test-token"
-MOCK_DEVICE_URL = "https://wdm-a.wbx2.com/wdm/api/v1/devices/test-device-id"
-MOCK_WS_URL = "wss://mercury.example.com/socket"
-MOCK_USER_ID = "user-123"
-
-MOCK_WDM_RESPONSE = {
-    "webSocketUrl": MOCK_WS_URL,
-    "url": MOCK_DEVICE_URL,
-    "userId": MOCK_USER_ID,
-    "services": {
-        "encryptionServiceUrl": "https://encryption.example.com",
-        "messenger": "https://messenger.example.com",
-    },
-}
-
-
-class TestRegister:
-    async def test_successful_registration(self):
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-        dm = DeviceManager(http_do=http_do)
-        result = await dm.register(MOCK_TOKEN)
-
-        assert result.web_socket_url == MOCK_WS_URL
-        assert result.device_url == MOCK_DEVICE_URL
-        assert result.user_id == MOCK_USER_ID
-        assert result.encryption_service_url == "https://encryption.example.com"
-        assert result.services["messenger"] == "https://messenger.example.com"
-
-    async def test_auth_error_on_401(self):
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, status=401)
-        dm = DeviceManager(http_do=http_do)
-        with pytest.raises(AuthError):
-            await dm.register(MOCK_TOKEN)
-
-    async def test_device_registration_error_on_non_2xx(self):
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, status=400)
-        dm = DeviceManager(http_do=http_do)
-        with pytest.raises(DeviceRegistrationError, match="Failed to register device"):
-            await dm.register(MOCK_TOKEN)
-
-    async def test_device_registration_error_on_network_failure(self):
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, exc=ConnectionError("Network error"))
-        dm = DeviceManager(http_do=http_do)
-        with pytest.raises(DeviceRegistrationError):
-            await dm.register(MOCK_TOKEN)
-
-
-class TestRefresh:
-    async def test_successful_refresh(self):
-        refreshed = {**MOCK_WDM_RESPONSE, "webSocketUrl": "wss://mercury-new.example.com/socket"}
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("PUT", MOCK_DEVICE_URL, payload=refreshed)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        result = await dm.refresh(MOCK_TOKEN)
-
-        assert result.web_socket_url == "wss://mercury-new.example.com/socket"
-
-    async def test_error_if_not_registered(self):
-        http_do = MockHttpDo()
-        dm = DeviceManager(http_do=http_do)
-        with pytest.raises(DeviceRegistrationError, match="Device not registered"):
-            await dm.refresh(MOCK_TOKEN)
-
-    async def test_auth_error_on_401_during_refresh(self):
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("PUT", MOCK_DEVICE_URL, status=401)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        with pytest.raises(AuthError):
-            await dm.refresh(MOCK_TOKEN)
-
-    async def test_device_registration_error_on_refresh_failure(self):
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("PUT", MOCK_DEVICE_URL, status=500)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        with pytest.raises(DeviceRegistrationError):
-            await dm.refresh(MOCK_TOKEN)
-
-
-class TestUnregister:
-    async def test_successful_unregister(self):
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("DELETE", MOCK_DEVICE_URL, status=204)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        await dm.unregister(MOCK_TOKEN)
-
-    async def test_error_if_not_registered(self):
-        http_do = MockHttpDo()
-        dm = DeviceManager(http_do=http_do)
-        with pytest.raises(DeviceRegistrationError, match="Device not registered"):
-            await dm.unregister(MOCK_TOKEN)
-
-    async def test_auth_error_on_401_during_unregister(self):
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("DELETE", MOCK_DEVICE_URL, status=401)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        with pytest.raises(AuthError):
-            await dm.unregister(MOCK_TOKEN)
-
-    async def test_device_registration_error_on_unregister_failure(self):
-        http_do = (
-            MockHttpDo()
-            .add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            .add("DELETE", MOCK_DEVICE_URL, status=500)
-        )
-        dm = DeviceManager(http_do=http_do)
-        await dm.register(MOCK_TOKEN)
-        with pytest.raises(DeviceRegistrationError):
-            await dm.unregister(MOCK_TOKEN)
-
-
-class TestServiceParsing:
-    async def test_empty_services(self):
-        response = {**MOCK_WDM_RESPONSE, "services": {}}
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, payload=response)
-        dm = DeviceManager(http_do=http_do)
-        result = await dm.register(MOCK_TOKEN)
-
-        assert result.services == {}
-        assert result.encryption_service_url == ""
-
-    async def test_missing_encryption_service_url(self):
-        response = {**MOCK_WDM_RESPONSE, "services": {"messenger": "https://messenger.example.com"}}
-        http_do = MockHttpDo().add("POST", WDM_API_BASE, payload=response)
-        dm = DeviceManager(http_do=http_do)
-        result = await dm.register(MOCK_TOKEN)
-
-        assert "messenger" in result.services
-        assert result.encryption_service_url == ""