webex-message-handler 0.4.4__tar.gz → 0.6.0__tar.gz

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webex-message-handler
-Version: 0.4.4
+Version: 0.6.0
 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

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "webex-message-handler"
-version = "0.4.4"
+version = "0.6.0"
 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.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/__init__.py

@@ -24,6 +24,7 @@ from .types import (
     FetchResponse,
     HandlerStatus,
     InjectedWebSocket,
+    MembershipActivity,
     MercuryActivity,
     MercuryActor,
     MercuryEnvelope,
@@ -63,6 +64,7 @@ __all__ = [
     "MercuryEnvelope",
     "DecryptedMessage",
     "DeletedMessage",
+    "MembershipActivity",
     "HandlerStatus",
     "ConnectionStatus",
     # Networking types

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/handler.py

@@ -23,6 +23,7 @@ from .types import (
     FetchResponse,
     HandlerStatus,
     InjectedWebSocket,
+    MembershipActivity,
     MercuryActivity,
     WebexMessageHandlerConfig,
     WebSocketFactory,
@@ -131,6 +132,7 @@ class WebexMessageHandler:
         self._listeners: dict[str, list[EventCallback]] = {
             "message:created": [],
             "message:deleted": [],
+            "membership:created": [],
             "connected": [],
             "disconnected": [],
             "reconnecting": [],
@@ -149,6 +151,7 @@ class WebexMessageHandler:
             session = aiohttp.ClientSession(
                 connector=connector,
                 connector_owner=connector is None,
+                trust_env=True,
             )
             try:
                 response = await session.request(
@@ -187,7 +190,7 @@ class WebexMessageHandler:
         """Create WebSocket adapter using native aiohttp."""
         async def ws_factory(url: str) -> InjectedWebSocket:
             session = aiohttp.ClientSession(connector=connector)
-            ws = await session.ws_connect(url)
+            ws = await session.ws_connect(url, max_msg_size=1 * 1024 * 1024)  # 1MB
 
             # Attach session for cleanup
             ws._session = session  # type: ignore[attr-defined]
@@ -236,7 +239,12 @@ class WebexMessageHandler:
             try:
                 result = callback(*args)
                 if asyncio.iscoroutine(result):
-                    asyncio.ensure_future(result)
+                    task = asyncio.ensure_future(result)
+                    task.add_done_callback(
+                        lambda t, ev=event: self._logger.error(
+                            f"Error in async {ev} listener: {t.exception()}"
+                        ) if not t.cancelled() and t.exception() else None
+                    )
             except Exception as exc:
                 self._logger.error(f"Error in {event} listener: {exc}")
 
@@ -452,7 +460,11 @@ class WebexMessageHandler:
                 raw=decrypted,
             )
             # Filter self-messages if enabled
-            if self._ignore_self_messages and self._bot_person_id and extract_person_uuid(message.person_id) == self._bot_person_id:
+            if (
+                self._ignore_self_messages
+                and self._bot_person_id
+                and extract_person_uuid(message.person_id) == self._bot_person_id
+            ):
                 self._logger.debug(f"Ignoring self-message from bot ({self._bot_person_id})")
                 return
 
@@ -469,6 +481,24 @@ class WebexMessageHandler:
                     person_id=activity.actor.id,
                 ),
             )
+            return
+
+        # membership:created — membership verbs + objectType=person
+        membership_verbs = {"add", "leave", "assignModerator", "unassignModerator"}
+        if activity.verb in membership_verbs and activity.object.object_type == "person":
+            self._emit(
+                "membership:created",
+                MembershipActivity(
+                    id=activity.id,
+                    actor_id=activity.actor.id,
+                    person_id=activity.object.id,
+                    room_id=activity.target.id,
+                    action=activity.verb,
+                    created=activity.published,
+                    room_type=self._infer_room_type(activity),
+                    raw=activity,
+                ),
+            )
 
     @staticmethod
     def _infer_room_type(activity: MercuryActivity) -> str | None:

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/kms_client.py

@@ -141,13 +141,18 @@ class KmsClient:
             response_body = _unwrap_kms_response(wrapped_response, local_ecdh_key)
             response_data = json.loads(response_body)
 
-            remote_jwk_data = response_data.get("body", {}).get("key", {}).get("jwk") or response_data.get("key", {}).get("jwk")
-            if not remote_jwk_data:
-                # Try alternate response structures
-                if "body" in response_data and "key" in response_data["body"]:
-                    remote_jwk_data = response_data["body"]["key"]
-                    if isinstance(remote_jwk_data, dict) and "jwk" in remote_jwk_data:
-                        remote_jwk_data = remote_jwk_data["jwk"]
+            remote_jwk_data = (
+                response_data.get("body", {}).get("key", {}).get("jwk")
+                or response_data.get("key", {}).get("jwk")
+            )
+            if (
+                not remote_jwk_data
+                and "body" in response_data
+                and "key" in response_data["body"]
+            ):
+                remote_jwk_data = response_data["body"]["key"]
+                if isinstance(remote_jwk_data, dict) and "jwk" in remote_jwk_data:
+                    remote_jwk_data = remote_jwk_data["jwk"]
 
             if not remote_jwk_data:
                 raise KmsError(
@@ -155,7 +160,18 @@ class KmsClient:
                 )
 
             # Step 7: Derive shared key via ECDH
-            remote_ecdh_key = jwk.JWK(**remote_jwk_data) if isinstance(remote_jwk_data, dict) else jwk.JWK(**json.loads(remote_jwk_data))
+            if isinstance(remote_jwk_data, dict):
+                remote_ecdh_key = jwk.JWK(**remote_jwk_data)
+            else:
+                remote_ecdh_key = jwk.JWK(**json.loads(remote_jwk_data))
+
+            # Validate remote key type and curve
+            key_type = remote_ecdh_key.get("kty")
+            key_curve = remote_ecdh_key.get("crv")
+            if key_type != "EC" or key_curve != "P-256":
+                raise KmsError(
+                    f"Invalid remote key type: kty={key_type}, crv={key_curve}"
+                )
 
             # Get the remote key URI for use as kid on the derived key
             remote_key_uri = (
@@ -239,14 +255,17 @@ class KmsClient:
             response_data = json.loads(response_body)
 
             # Extract the content key
-            key_data = response_data.get("body", {}).get("key", {}).get("jwk") or response_data.get("key", {}).get("jwk")
-            if not key_data:
-                if "body" in response_data and "key" in response_data["body"]:
-                    key_obj = response_data["body"]["key"]
-                    if isinstance(key_obj, dict) and "jwk" in key_obj:
-                        key_data = key_obj["jwk"]
-                    else:
-                        key_data = key_obj
+            key_data = (
+                response_data.get("body", {}).get("key", {}).get("jwk")
+                or response_data.get("key", {}).get("jwk")
+            )
+            if (
+                not key_data
+                and "body" in response_data
+                and "key" in response_data["body"]
+            ):
+                key_obj = response_data["body"]["key"]
+                key_data = key_obj["jwk"] if isinstance(key_obj, dict) and "jwk" in key_obj else key_obj
 
             if not key_data:
                 raise KmsError("No key found in KMS response")
@@ -278,6 +297,9 @@ class KmsClient:
             ),
         )
 
+        if len(self._pending_requests) >= 100:
+            self._logger.warning("KMS pending requests queue is large (%d), possible leak", len(self._pending_requests))
+
         self._pending_requests[request_id] = _PendingRequest(future=future, timeout_handle=timeout_handle)
 
         # POST the request
@@ -370,8 +392,6 @@ def _derive_ecdh_shared_key(local_key: jwk.JWK, remote_key: jwk.JWK, *, kid: str
     from cryptography.hazmat.primitives.hashes import SHA256
     from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
-    # Get cryptography private key from local JWK
-    local_private = local_key.get_op_key("sign") if local_key.has_private else local_key.get_op_key("unwrapKey")
     # For EC keys, get the actual private key object
     local_crypto_key = local_key._get_private_key() if hasattr(local_key, '_get_private_key') else None
 

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/mercury_socket.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import math
 import uuid
@@ -48,6 +49,7 @@ class MercurySocket:
         self._should_reconnect = True
         self._reconnect_attempts = 0
         self._pending_pong_id: str | None = None
+        self._reconnecting = False
 
         self._ping_task: asyncio.Task[None] | None = None
         self._read_task: asyncio.Task[None] | None = None
@@ -160,9 +162,9 @@ class MercurySocket:
         # Wait for connection ready or error
         try:
             await asyncio.wait_for(ready_event.wait(), timeout=30.0)
-        except asyncio.TimeoutError:
+        except asyncio.TimeoutError as exc:
             await self._cleanup_ws()
-            raise MercuryConnectionError("Mercury connection timeout waiting for ready signal")
+            raise MercuryConnectionError("Mercury connection timeout waiting for ready signal") from exc
 
         if connect_error:
             await self._cleanup_ws()
@@ -213,7 +215,8 @@ class MercurySocket:
         self._logger.warning(f"Pong timeout for ping {self._pending_pong_id}, reconnecting")
         self._pending_pong_id = None
         await self._close_websocket()
-        await self._reconnect()
+        if not self._reconnecting:
+            await self._reconnect()
 
     def _handle_message(self, message: dict[str, Any]) -> None:
         try:
@@ -288,37 +291,43 @@ class MercurySocket:
             self._emit("disconnected", "manual")
 
     async def _reconnect(self) -> None:
-        if not self._should_reconnect:
+        if self._reconnecting:
             return
+        self._reconnecting = True
+        try:
+            if not self._should_reconnect:
+                return
 
-        if self._reconnect_attempts >= self._max_reconnect_attempts:
-            self._logger.error(f"Max reconnection attempts ({self._max_reconnect_attempts}) exceeded")
-            self._should_reconnect = False
-            self._emit("disconnected", "max-attempts-exceeded")
-            return
+            if self._reconnect_attempts >= self._max_reconnect_attempts:
+                self._logger.error(f"Max reconnection attempts ({self._max_reconnect_attempts}) exceeded")
+                self._should_reconnect = False
+                self._emit("disconnected", "max-attempts-exceeded")
+                return
 
-        self._reconnect_attempts += 1
-        delay = min(1.0 * math.pow(2, self._reconnect_attempts - 1), self._reconnect_backoff_max)
+            self._reconnect_attempts += 1
+            delay = min(1.0 * math.pow(2, self._reconnect_attempts - 1), self._reconnect_backoff_max)
 
-        self._logger.info(
-            f"Reconnecting (attempt {self._reconnect_attempts}/{self._max_reconnect_attempts}) in {delay}s"
-        )
-        self._emit("reconnecting", self._reconnect_attempts)
+            self._logger.info(
+                f"Reconnecting (attempt {self._reconnect_attempts}/{self._max_reconnect_attempts}) in {delay}s"
+            )
+            self._emit("reconnecting", self._reconnect_attempts)
 
-        await asyncio.sleep(delay)
+            await asyncio.sleep(delay)
 
-        if not self._should_reconnect:
-            return
+            if not self._should_reconnect:
+                return
 
-        try:
-            await self._connect_internal()
-            self._logger.info("Successfully reconnected to Mercury")
-            self._reconnect_attempts = 0
-            self._emit("connected")
-        except Exception as exc:
-            self._logger.error(f"Reconnection failed: {exc}")
-            if self._should_reconnect:
-                await self._reconnect()
+            try:
+                await self._connect_internal()
+                self._logger.info("Successfully reconnected to Mercury")
+                self._reconnect_attempts = 0
+                self._emit("connected")
+            except Exception as exc:
+                self._logger.error(f"Reconnection failed: {exc}")
+                if self._should_reconnect:
+                    await self._reconnect()
+        finally:
+            self._reconnecting = False
 
     def _stop_ping_loop(self) -> None:
         if self._ping_task and not self._ping_task.done():
@@ -330,17 +339,21 @@ class MercurySocket:
         self._pending_pong_id = None
 
     async def _close_websocket(self) -> None:
-        if self._ws and not self._ws.closed:
-            await self._ws.close(code=1000)
+        if self._ws is not None:
+            # Close attached session if present (native mode)
+            session = getattr(self._ws, '_session', None)
+            if session and not session.closed:
+                await session.close()
+            if not self._ws.closed:
+                await self._ws.close(code=1000)
+            self._ws = None
 
     async def _cleanup_ws(self) -> None:
         self._stop_ping_loop()
         if self._read_task and not self._read_task.done():
             self._read_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self._read_task
-            except asyncio.CancelledError:
-                pass
         await self._close_websocket()
         self._ws = None
 
@@ -351,10 +364,8 @@ class MercurySocket:
         self._stop_ping_loop()
         if self._read_task and not self._read_task.done():
             self._read_task.cancel()
-            try:
+            with contextlib.suppress(asyncio.CancelledError):
                 await self._read_task
-            except asyncio.CancelledError:
-                pass
         await self._close_websocket()
         self._ws = None
         self._connection_ready = False

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/message_decryptor.py

@@ -53,7 +53,11 @@ class MessageDecryptor:
             decrypted.object = copy.copy(activity.object)
 
             # Decrypt displayName
-            if decrypted.object.display_name and isinstance(decrypted.object.display_name, str) and len(decrypted.object.display_name) > 0:
+            if (
+                decrypted.object.display_name
+                and isinstance(decrypted.object.display_name, str)
+                and len(decrypted.object.display_name) > 0
+            ):
                 try:
                     jwe_obj = jwe.JWE()
                     jwe_obj.deserialize(decrypted.object.display_name, key=key)
@@ -64,7 +68,11 @@ class MessageDecryptor:
                     )
 
             # Decrypt content
-            if decrypted.object.content and isinstance(decrypted.object.content, str) and len(decrypted.object.content) > 0:
+            if (
+                decrypted.object.content
+                and isinstance(decrypted.object.content, str)
+                and len(decrypted.object.content) > 0
+            ):
                 try:
                     jwe_obj = jwe.JWE()
                     jwe_obj.deserialize(decrypted.object.content, key=key)

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/src/webex_message_handler/types.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Literal, Protocol
+from typing import TYPE_CHECKING, Any, Literal, Protocol
 
 if TYPE_CHECKING:
     import aiohttp
@@ -228,6 +229,35 @@ class DeletedMessage:
     person_id: str
 
 
+@dataclass
+class MembershipActivity:
+    """A membership activity from Mercury."""
+
+    id: str
+    """Activity ID."""
+
+    actor_id: str
+    """ID of the person who performed the action."""
+
+    person_id: str
+    """ID of the member affected."""
+
+    room_id: str
+    """Conversation/space ID."""
+
+    action: str
+    """Membership action: "add", "leave", "assignModerator", or "unassignModerator"."""
+
+    created: str
+    """ISO 8601 timestamp."""
+
+    room_type: str | None = None
+    """'direct' | 'group' | None."""
+
+    raw: MercuryActivity | None = None
+    """Full raw activity for advanced use."""
+
+
 # --- Status ---
 
 ConnectionStatus = Literal["connected", "connecting", "reconnecting", "disconnected"]

webex_message_handler-0.6.0/test-proxy.py

@@ -0,0 +1,79 @@
+"""Proxy validation test via mitmproxy.
+
+Run with: WEBEX_BOT_TOKEN=... python test-proxy.py
+Requires mitmproxy running on localhost:8080.
+"""
+
+import asyncio
+import os
+import ssl
+import sys
+
+import aiohttp
+from aiohttp import TCPConnector
+
+# Add src to path for local development
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from webex_message_handler import WebexMessageHandler, WebexMessageHandlerConfig, console_logger
+
+
+async def main() -> None:
+    token = os.environ.get("WEBEX_BOT_TOKEN")
+    if not token:
+        print("Error: WEBEX_BOT_TOKEN environment variable not set")
+        sys.exit(1)
+
+    proxy_url = os.environ.get("HTTPS_PROXY", "http://localhost:8080")
+    # Set HTTPS_PROXY so aiohttp's trust_env picks it up
+    os.environ["HTTPS_PROXY"] = proxy_url
+    os.environ["HTTP_PROXY"] = proxy_url
+
+    print(f"\n=== Webex Proxy Test (Python) ===")
+    print(f"Using proxy: {proxy_url}\n")
+
+    # Create aiohttp connector with disabled SSL verification for mitmproxy
+    ssl_ctx = ssl.create_default_context()
+    ssl_ctx.check_hostname = False
+    ssl_ctx.verify_mode = ssl.CERT_NONE
+
+    connector = TCPConnector(ssl=ssl_ctx)
+
+    config = WebexMessageHandlerConfig(
+        token=token,
+        connector=connector,
+        logger=console_logger,
+    )
+
+    handler = WebexMessageHandler(config)
+
+    connected_event = asyncio.Event()
+
+    @handler.on("connected")
+    def on_connected() -> None:
+        print("\nSUCCESS: Connected through proxy!")
+        print("   - Device registered")
+        print("   - Mercury WebSocket connected")
+        print("   - KMS initialized")
+        connected_event.set()
+
+    @handler.on("error")
+    def on_error(err: Exception) -> None:
+        print(f"\nERROR: {err}")
+        sys.exit(1)
+
+    print("Connecting to Webex through proxy...")
+    try:
+        await handler.connect()
+        await asyncio.sleep(3)
+        print("\nProxy validation complete - disconnecting...\n")
+        await handler.disconnect()
+        await connector.close()
+        print("SUCCESS: Python proxy test passed")
+    except Exception as e:
+        print(f"FAILED: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/tests/conftest.py

@@ -8,13 +8,15 @@ 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:
-            async with session.request(
+        async with (
+            aiohttp.ClientSession(connector=connector) as session,
+            session.request(
                 request.method,
                 request.url,
                 headers=request.headers,
                 data=request.body,
-            ) as response:
+            ) as response,
+        ):
                 # Eagerly read the response body before the context closes
                 body_bytes = await response.read()
                 status = response.status

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/tests/test_handler.py

@@ -6,7 +6,6 @@ import pytest
 
 from webex_message_handler.handler import WebexMessageHandler
 from webex_message_handler.types import (
-    DecryptedMessage,
     DeviceRegistration,
     MercuryActivity,
     MercuryActor,
@@ -37,7 +36,10 @@ def _make_activity(**overrides) -> MercuryActivity:
         "id": "msg-123",
         "verb": "post",
         "actor": MercuryActor(id="person-456", object_type="person", email_address="user@example.com"),
-        "object": MercuryObject(id="comment-789", object_type="comment", display_name="Test Message", content="<p>Test Message</p>"),
+        "object": MercuryObject(
+            id="comment-789", object_type="comment",
+            display_name="Test Message", content="<p>Test Message</p>",
+        ),
         "target": MercuryTarget(id="room-101", object_type="conversation", tags=["GROUP"]),
         "published": "2024-01-01T00:00:00Z",
     }
@@ -282,6 +284,118 @@ class TestMessageHandling:
         assert len(messages) == 0
 
 
+class TestMembershipHandling:
+    async def test_handle_membership_add(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        evt = events[0]
+        assert evt.id == "msg-123"
+        assert evt.actor_id == "person-456"
+        assert evt.person_id == "member-789"
+        assert evt.room_id == "room-101"
+        assert evt.action == "add"
+        assert evt.created == "2024-01-01T00:00:00Z"
+        assert evt.room_type == "group"
+
+    async def test_handle_membership_leave(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="leave",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "leave"
+
+    async def test_handle_membership_assign_moderator(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="assignModerator",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "assignModerator"
+
+    async def test_handle_membership_unassign_moderator(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="unassignModerator",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].action == "unassignModerator"
+
+    async def test_non_membership_verb_with_person_object(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="post",
+            object=MercuryObject(id="person-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 0
+
+    async def test_membership_verb_with_non_person_object(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="comment-789", object_type="comment"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 0
+
+    async def test_membership_includes_raw_activity(self):
+        handler = _make_handler()
+        activity = _make_activity(
+            verb="add",
+            object=MercuryObject(id="member-789", object_type="person"),
+        )
+
+        events = []
+        handler.on("membership:created", lambda a: events.append(a))
+
+        await handler._handle_activity(activity)
+
+        assert len(events) == 1
+        assert events[0].raw is activity
+
+
 class TestStatus:
     def test_disconnected_status(self):
         handler = _make_handler()

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/tests/test_integration.py

@@ -81,7 +81,9 @@ async def test_integration_send_and_receive():
                 "https://webexapis.com/v1/people/me",
                 headers={"Authorization": f"Bearer {sender_token}"}
             ) as sender_response:
-                assert receiver_response.status == 200, f"Failed to get receiver bot identity: {receiver_response.status}"
+                assert receiver_response.status == 200, (
+                    f"Failed to get receiver bot identity: {receiver_response.status}"
+                )
                 assert sender_response.status == 200, f"Failed to get sender bot identity: {sender_response.status}"
                 receiver = await receiver_response.json()
                 sender = await sender_response.json()

{webex_message_handler-0.4.4 → webex_message_handler-0.6.0}/tests/test_message_decryptor.py

@@ -55,7 +55,6 @@ class TestDecryptActivity:
             mock_jwe_obj2.payload = b"decrypted-content"
 
             call_count = [0]
-            original_init = mock_jwe.JWE
 
             def side_effect():
                 call_count[0] += 1