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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webex-message-handler
-Version: 0.6.11
+Version: 0.6.12
 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
@@ -19,11 +19,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Communications :: Chat
 Requires-Python: >=3.10
-Requires-Dist: aiohttp>=3.13.4
-Requires-Dist: cryptography>=46.0.7
+Requires-Dist: aiohttp>=3.14.1
+Requires-Dist: cryptography>=48.0.1
 Requires-Dist: jwcrypto>=1.5.7
 Provides-Extra: dev
-Requires-Dist: aioresponses>=0.7; extra == 'dev'
 Requires-Dist: mypy>=1.10; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=7; extra == 'dev'

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "webex-message-handler"
-version = "0.6.11"
+version = "0.6.12"
 description = "Lightweight Webex Mercury WebSocket + KMS decryption for receiving bot messages without the full Webex SDK"
 readme = "README.md"
 license = "MIT"
@@ -26,8 +26,8 @@ classifiers = [
     "Framework :: AsyncIO",
 ]
 dependencies = [
-    "aiohttp>=3.13.4",
-    "cryptography>=46.0.7",
+    "aiohttp>=3.14.1",
+    "cryptography>=48.0.1",
     "jwcrypto>=1.5.7",
 ]
 
@@ -57,7 +57,6 @@ strict = true
 dev = [
     "pytest>=7",
     "pytest-asyncio>=0.23",
-    "aioresponses>=0.7",
     "ruff>=0.4",
     "mypy>=1.10",
 ]

webex_message_handler-0.6.12/tests/conftest.py

@@ -0,0 +1,89 @@
+"""Pytest configuration and fixtures."""
+
+import json as _json
+
+import aiohttp
+
+from webex_message_handler.types import FetchRequest, FetchResponse
+
+
+class MockHttpResponse:
+    """A canned FetchResponse for the injected http_do adapter."""
+
+    def __init__(self, status: int = 200, payload=None, *, exc: Exception | None = None):
+        self.status = status
+        self.ok = 200 <= status < 300
+        self._payload = payload
+        self._exc = exc
+
+    async def json(self):
+        return self._payload
+
+    async def text(self):
+        return _json.dumps(self._payload) if self._payload is not None else ""
+
+
+class MockHttpDo:
+    """Mocks HTTP at the injected ``http_do`` seam instead of patching aiohttp.
+
+    Register canned responses keyed by ``(METHOD, url)``; the adapter pops them
+    in registration order so repeated calls to the same endpoint can return
+    different responses. A registered ``Exception`` is raised to simulate a
+    network failure (mirroring the handler's try/except path).
+    """
+
+    def __init__(self):
+        self._routes: dict[tuple[str, str], list] = {}
+        self.calls: list[FetchRequest] = []
+
+    def add(self, method: str, url: str, *, status: int = 200, payload=None, exc: Exception | None = None):
+        self._routes.setdefault((method.upper(), url), []).append(
+            MockHttpResponse(status=status, payload=payload, exc=exc)
+        )
+        return self
+
+    async def __call__(self, request: FetchRequest) -> FetchResponse:
+        self.calls.append(request)
+        key = (request.method.upper(), request.url)
+        queue = self._routes.get(key)
+        if not queue:
+            raise AssertionError(f"unexpected request: {request.method} {request.url}")
+        response = queue.pop(0) if len(queue) > 1 else queue[0]
+        if response._exc is not None:
+            raise response._exc
+        return response  # type: ignore[return-value]
+
+
+async def create_test_http_do(connector: aiohttp.BaseConnector | None = None):
+    """Create a test HTTP adapter for use in tests."""
+    async def http_do(request: FetchRequest) -> FetchResponse:
+        async with (
+            aiohttp.ClientSession(connector=connector) as session,
+            session.request(
+                request.method,
+                request.url,
+                headers=request.headers,
+                data=request.body,
+            ) as response,
+        ):
+                # Eagerly read the response body before the context closes
+                body_bytes = await response.read()
+                status = response.status
+                ok = 200 <= status < 300
+
+                class TestFetchResponse:
+                    def __init__(self):
+                        self.status = status
+                        self.ok = ok
+                        self._body = body_bytes
+
+                    async def json(self):
+                        import json
+                        return json.loads(self._body.decode('utf-8'))
+
+                    async def text(self):
+                        return self._body.decode('utf-8')
+
+                return TestFetchResponse()  # type: ignore[return-value]
+
+    return http_do

{webex_message_handler-0.6.11 → webex_message_handler-0.6.12}/tests/test_device_manager.py

@@ -1,9 +1,8 @@
 """Tests for DeviceManager."""
 
 import pytest
-from aioresponses import aioresponses
 
-from tests.conftest import create_test_http_do
+from tests.conftest import MockHttpDo
 from webex_message_handler.device_manager import WDM_API_BASE, DeviceManager
 from webex_message_handler.errors import AuthError, DeviceRegistrationError
 
@@ -25,11 +24,9 @@ MOCK_WDM_RESPONSE = {
 
 class TestRegister:
     async def test_successful_registration(self):
-        http_do = await create_test_http_do()
+        http_do = MockHttpDo().add("POST", WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
         dm = DeviceManager(http_do=http_do)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            result = await dm.register(MOCK_TOKEN)
+        result = await dm.register(MOCK_TOKEN)
 
         assert result.web_socket_url == MOCK_WS_URL
         assert result.device_url == MOCK_DEVICE_URL
@@ -38,127 +35,122 @@ class TestRegister:
         assert result.services["messenger"] == "https://messenger.example.com"
 
     async def test_auth_error_on_401(self):
-        http_do = await create_test_http_do()
+        http_do = MockHttpDo().add("POST", WDM_API_BASE, status=401)
         dm = DeviceManager(http_do=http_do)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, status=401)
-            with pytest.raises(AuthError):
-                await dm.register(MOCK_TOKEN)
+        with pytest.raises(AuthError):
+            await dm.register(MOCK_TOKEN)
 
     async def test_device_registration_error_on_non_2xx(self):
-        http_do = await create_test_http_do()
+        http_do = MockHttpDo().add("POST", WDM_API_BASE, status=400)
         dm = DeviceManager(http_do=http_do)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, status=400)
-            with pytest.raises(DeviceRegistrationError, match="Failed to register device"):
-                await dm.register(MOCK_TOKEN)
+        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 = await create_test_http_do()
+        http_do = MockHttpDo().add("POST", WDM_API_BASE, exc=ConnectionError("Network error"))
         dm = DeviceManager(http_do=http_do)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, exception=ConnectionError("Network error"))
-            with pytest.raises(DeviceRegistrationError):
-                await dm.register(MOCK_TOKEN)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.register(MOCK_TOKEN)
 
 
 class TestRefresh:
     async def test_successful_refresh(self):
-        http_do = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-
-            refreshed = {**MOCK_WDM_RESPONSE, "webSocketUrl": "wss://mercury-new.example.com/socket"}
-            m.put(MOCK_DEVICE_URL, payload=refreshed)
-            result = await dm.refresh(MOCK_TOKEN)
+        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 = await create_test_http_do()
+        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 = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-            m.put(MOCK_DEVICE_URL, status=401)
-            with pytest.raises(AuthError):
-                await dm.refresh(MOCK_TOKEN)
+        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 = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-            m.put(MOCK_DEVICE_URL, status=500)
-            with pytest.raises(DeviceRegistrationError):
-                await dm.refresh(MOCK_TOKEN)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.refresh(MOCK_TOKEN)
 
 
 class TestUnregister:
     async def test_successful_unregister(self):
-        http_do = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-            m.delete(MOCK_DEVICE_URL, status=204)
-            await dm.unregister(MOCK_TOKEN)
+        await dm.register(MOCK_TOKEN)
+        await dm.unregister(MOCK_TOKEN)
 
     async def test_error_if_not_registered(self):
-        http_do = await create_test_http_do()
+        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 = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-            m.delete(MOCK_DEVICE_URL, status=401)
-            with pytest.raises(AuthError):
-                await dm.unregister(MOCK_TOKEN)
+        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 = await create_test_http_do()
+        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)
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=MOCK_WDM_RESPONSE)
-            await dm.register(MOCK_TOKEN)
-            m.delete(MOCK_DEVICE_URL, status=500)
-            with pytest.raises(DeviceRegistrationError):
-                await dm.unregister(MOCK_TOKEN)
+        await dm.register(MOCK_TOKEN)
+        with pytest.raises(DeviceRegistrationError):
+            await dm.unregister(MOCK_TOKEN)
 
 
 class TestServiceParsing:
     async def test_empty_services(self):
-        http_do = await create_test_http_do()
-        dm = DeviceManager(http_do=http_do)
         response = {**MOCK_WDM_RESPONSE, "services": {}}
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=response)
-            result = await dm.register(MOCK_TOKEN)
+        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):
-        http_do = await create_test_http_do()
-        dm = DeviceManager(http_do=http_do)
         response = {**MOCK_WDM_RESPONSE, "services": {"messenger": "https://messenger.example.com"}}
-        with aioresponses() as m:
-            m.post(WDM_API_BASE, payload=response)
-            result = await dm.register(MOCK_TOKEN)
+        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 == ""

webex_message_handler-0.6.11/tests/conftest.py

@@ -1,40 +0,0 @@
-"""Pytest configuration and fixtures."""
-
-import aiohttp
-
-from webex_message_handler.types import FetchRequest, FetchResponse
-
-
-async def create_test_http_do(connector: aiohttp.BaseConnector | None = None):
-    """Create a test HTTP adapter for use in tests."""
-    async def http_do(request: FetchRequest) -> FetchResponse:
-        async with (
-            aiohttp.ClientSession(connector=connector) as session,
-            session.request(
-                request.method,
-                request.url,
-                headers=request.headers,
-                data=request.body,
-            ) as response,
-        ):
-                # Eagerly read the response body before the context closes
-                body_bytes = await response.read()
-                status = response.status
-                ok = 200 <= status < 300
-
-                class TestFetchResponse:
-                    def __init__(self):
-                        self.status = status
-                        self.ok = ok
-                        self._body = body_bytes
-
-                    async def json(self):
-                        import json
-                        return json.loads(self._body.decode('utf-8'))
-
-                    async def text(self):
-                        return self._body.decode('utf-8')
-
-                return TestFetchResponse()  # type: ignore[return-value]
-
-    return http_do