fix test

Author: YonkoSam

tests/__pycache__/test_webhooks.cpython-313-pytest-8.3.5.pyc

@@ -71,7 +71,7 @@ def test_rejects_none_configured_secret(self):
 class TestWebhookEventHandling:
     @pytest.mark.asyncio
     async def test_client_handle_webhook_rejects_invalid_signature(self, client_for_webhook_tests):
-        payload = {"type": "something"}
+        payload = {"event": "something"}
         mock_req = make_req_for_client_test(payload) # No signature
         with pytest.raises(WasenderAPIError, match="Invalid webhook signature"):
             await client_for_webhook_tests.handle_webhook_event(
@@ -81,7 +81,7 @@ async def test_client_handle_webhook_rejects_invalid_signature(self, client_for_
 
     @pytest.mark.asyncio
     async def test_client_handle_webhook_rejects_incorrect_signature(self, client_for_webhook_tests):
-        payload = {"type": "something"}
+        payload = {"event": "something"}
         mock_req = make_req_for_client_test(payload, "wrongsecret")
         with pytest.raises(WasenderAPIError, match="Invalid webhook signature"):
             await client_for_webhook_tests.handle_webhook_event(
@@ -96,20 +96,20 @@ async def test_client_handle_webhook_parses_valid_event(self, client_for_webhook
             "conversationTimestamp": 1633456789, "unreadCount": 2
         }
         payload = {
-            "type": WebhookEventType.CHATS_UPSERT.value,
+            "event": WebhookEventType.CHATS_UPSERT.value,
             "timestamp": 1633456789,
             "data": [chat_entry],
             "sessionId": "session-id-123"
         }
         mock_req = make_req_for_client_test(payload, SECRET)
-        evt = await client_for_webhook_tests.handle_webhook_event(
+        payload = await client_for_webhook_tests.handle_webhook_event(
             request_body_bytes=mock_req.body,
             signature_header=mock_req.headers.get(WEBHOOK_SIGNATURE_HEADER)
         )
-        assert evt.type == WebhookEventType.CHATS_UPSERT
-        assert evt.data[0].id == chat_entry["id"]
-        assert evt.timestamp == 1633456789
-        assert evt.session_id == "session-id-123"
+        assert payload.event == WebhookEventType.CHATS_UPSERT
+        assert payload.data[0].id == chat_entry["id"]
+        assert payload.timestamp == 1633456789
+        assert payload.session_id == "session-id-123"
 
     # Tests for direct Pydantic model parsing
     def test_parses_chats_upsert_event_correctly_model(self):
@@ -118,44 +118,44 @@ def test_parses_chats_upsert_event_correctly_model(self):
             "conversationTimestamp": 1633456789, "unreadCount": 2
         }
         payload = {
-            "type": WebhookEventType.CHATS_UPSERT.value,
+            "event": WebhookEventType.CHATS_UPSERT.value,
             "timestamp": 1633456789,
             "data": [chat_entry_data],
             "sessionId": "session-id-123"
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.CHATS_UPSERT
-        assert isinstance(evt.data, list)
-        assert evt.data[0].id == chat_entry_data["id"]
-        assert evt.data[0].name == chat_entry_data["name"]
-        assert evt.timestamp == 1633456789
-        assert evt.session_id == "session-id-123"
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.CHATS_UPSERT
+        assert isinstance(payload.data, list)
+        assert payload.data[0].id == chat_entry_data["id"]
+        assert payload.data[0].name == chat_entry_data["name"]
+        assert payload.timestamp == 1633456789
+        assert payload.session_id == "session-id-123"
 
     def test_parses_chats_update_event_correctly_model(self):
         chat_update_data = {
             "id": "1234567890", "unreadCount": 0, "conversationTimestamp": 1633456789
         }
         payload = {
-            "type": WebhookEventType.CHATS_UPDATE.value,
+            "event": WebhookEventType.CHATS_UPDATE.value,
             "timestamp": 1633456789,
             "data": [chat_update_data]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.CHATS_UPDATE
-        assert evt.data[0].unread_count == chat_update_data["unreadCount"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.CHATS_UPDATE
+        assert payload.data[0].unread_count == chat_update_data["unreadCount"]
 
     def test_parses_chats_delete_event_correctly_model(self):
         payload = {
-            "type": WebhookEventType.CHATS_DELETE.value,
+            "event": WebhookEventType.CHATS_DELETE.value,
             "timestamp": 1633456789,
             "data": ["1234567890"]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.CHATS_DELETE
-        assert evt.data == ["1234567890"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.CHATS_DELETE
+        assert payload.data == ["1234567890"]
 
     def test_parses_groups_upsert_event_correctly_model(self):
         participant1_data = {"id": "[email protected]", "admin": "superadmin"}
@@ -171,17 +171,17 @@ def test_parses_groups_upsert_event_correctly_model(self):
             "participants": [participant1_data, participant2_data, participant3_data]
         }
         payload = {
-            "type": WebhookEventType.GROUPS_UPSERT.value,
+            "event": WebhookEventType.GROUPS_UPSERT.value,
             "timestamp": 1633456789,
             "data": [group_data]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
+        payload = adapter.validate_python(payload)
 
-        assert evt.type == WebhookEventType.GROUPS_UPSERT
-        assert isinstance(evt.data, list)
-        assert len(evt.data) == 1
-        parsed_group_metadata = evt.data[0]
+        assert payload.event == WebhookEventType.GROUPS_UPSERT
+        assert isinstance(payload.data, list)
+        assert len(payload.data) == 1
+        parsed_group_metadata = payload.data[0]
         assert isinstance(parsed_group_metadata, WebhookGroupMetadata)
         assert parsed_group_metadata.jid == group_data["jid"]
         assert parsed_group_metadata.subject == group_data["subject"]
@@ -201,59 +201,59 @@ def test_parses_groups_update_event_correctly_model(self):
             "restrict": False
         }
         payload = {
-            "type": WebhookEventType.GROUPS_UPDATE.value,
+            "event": WebhookEventType.GROUPS_UPDATE.value,
             "timestamp": 1633456789,
             "data": [group_update_data]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.GROUPS_UPDATE
-        assert evt.data[0].announce == group_update_data["announce"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.GROUPS_UPDATE
+        assert payload.data[0].announce == group_update_data["announce"]
 
     def test_parses_group_participants_update_event_correctly_model(self):
         participants_update_data = {
             "jid": "[email protected]", "participants": ["1234567890"], "action": "add"
         }
         payload = {
-            "type": WebhookEventType.GROUP_PARTICIPANTS_UPDATE.value,
+            "event": WebhookEventType.GROUP_PARTICIPANTS_UPDATE.value,
             "timestamp": 1633456789,
             "data": participants_update_data
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.GROUP_PARTICIPANTS_UPDATE
-        assert evt.data.action == participants_update_data["action"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.GROUP_PARTICIPANTS_UPDATE
+        assert payload.data.action == participants_update_data["action"]
 
     def test_parses_contacts_upsert_event_correctly_model(self):
         contact_data = {
             "jid": "1234567890", "name": "Contact Name", "notify": "Contact Display Name",
             "verifiedName": "Verified Business Name", "status": "Hey there! I am using WhatsApp."
         }
         payload = {
-            "type": WebhookEventType.CONTACTS_UPSERT.value,
+            "event": WebhookEventType.CONTACTS_UPSERT.value,
             "timestamp": 1633456789,
             "data": [contact_data]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.CONTACTS_UPSERT
-        assert evt.data[0].verified_name == contact_data["verifiedName"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.CONTACTS_UPSERT
+        assert payload.data[0].verified_name == contact_data["verifiedName"]
 
     def test_parses_contacts_update_event_correctly_model(self):
         contact_update_data = {
             "jid": "1234567890",
             "imgUrl": "https://pps.whatsapp.net/v/t61.24694-24/some.jpg"
         }
         payload = {
-            "type": WebhookEventType.CONTACTS_UPDATE.value,
+            "event": WebhookEventType.CONTACTS_UPDATE.value,
             "timestamp": 1633456789,
             "data": [contact_update_data]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.CONTACTS_UPDATE
-        assert evt.data[0].img_url == contact_update_data["imgUrl"]
-        assert evt.data[0].jid == contact_update_data["jid"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.CONTACTS_UPDATE
+        assert payload.data[0].img_url == contact_update_data["imgUrl"]
+        assert payload.data[0].jid == contact_update_data["jid"]
 
     def test_parses_messages_upsert_event_correctly_model(self):
         message_key_data = {"remoteJid": "[email protected]", "id": "ABC", "fromMe": False}
@@ -263,115 +263,115 @@ def test_parses_messages_upsert_event_correctly_model(self):
             "message": message_content_data, "pushName": "Sender Name"
         }
         payload = {
-            "type": WebhookEventType.MESSAGES_UPSERT.value,
+            "event": WebhookEventType.MESSAGES_UPSERT.value,
             "timestamp": 1633456789,
             "data": messages_upsert_data # Note: Node.js data was List[MessageUpsertData]
                                         # Python model in webhook.py is MessagesUpsertData (singular)
                                         # Test adapted to singular data based on Python model def.
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGES_UPSERT
-        assert evt.data.key.id == message_key_data["id"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGES_UPSERT
+        assert payload.data.key.id == message_key_data["id"]
 
     def test_parses_messages_update_event_correctly_model(self):
         message_key_data = {"remoteJid": "[email protected]", "id": "ABC", "fromMe": True}
         message_update_data = {"status": "read"}
         messages_update_data_entry = {"key": message_key_data, "update": message_update_data}
         payload = {
-            "type": WebhookEventType.MESSAGES_UPDATE.value,
+            "event": WebhookEventType.MESSAGES_UPDATE.value,
             "timestamp": 1633456789,
             "data": [messages_update_data_entry]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGES_UPDATE
-        assert evt.data[0].key.id == message_key_data["id"]
-        assert evt.data[0].update.status == message_update_data["status"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGES_UPDATE
+        assert payload.data[0].key.id == message_key_data["id"]
+        assert payload.data[0].update.status == message_update_data["status"]
 
     def test_parses_messages_delete_event_correctly_model(self):
         message_key_data = {"remoteJid": "[email protected]", "id": "DEF", "fromMe": False}
         payload = {
-            "type": WebhookEventType.MESSAGES_DELETE.value,
+            "event": WebhookEventType.MESSAGES_DELETE.value,
             "timestamp": 1633456789,
             "data": {"keys": [message_key_data]}
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGES_DELETE
-        assert evt.data.keys[0].id == message_key_data["id"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGES_DELETE
+        assert payload.data.keys[0].id == message_key_data["id"]
 
     def test_parses_message_sent_event_correctly_model(self):
         message_sent_data = {
             "key": {"remoteJid": "[email protected]", "id": "MSGID", "fromMe": True}, # Added key to match model
             "status": "sent", "timestamp": 1633456789
         }
         payload = {
-            "type": WebhookEventType.MESSAGE_SENT.value,
+            "event": WebhookEventType.MESSAGE_SENT.value,
             "timestamp": 1633456789,
             "data": message_sent_data
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGE_SENT
-        assert evt.data.status == message_sent_data["status"]
-        assert evt.data.key.id == message_sent_data["key"]["id"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGE_SENT
+        assert payload.data.status == message_sent_data["status"]
+        assert payload.data.key.id == message_sent_data["key"]["id"]
 
     def test_parses_message_receipt_update_event_correctly_model(self):
         receipt_data = {"userJid": "[email protected]", "status": "read", "t": 1633456800}
         message_key_data = {"remoteJid": "[email protected]", "id": "MSGID", "fromMe": True}
         message_receipt_update_data_entry = {"key": message_key_data, "receipt": receipt_data}
         payload = {
-            "type": WebhookEventType.MESSAGE_RECEIPT_UPDATE.value,
+            "event": WebhookEventType.MESSAGE_RECEIPT_UPDATE.value,
             "timestamp": 1633456789,
             "data": [message_receipt_update_data_entry] # Data is a list
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGE_RECEIPT_UPDATE
-        assert evt.data[0].key.id == message_key_data["id"]
-        assert evt.data[0].receipt.status == receipt_data["status"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGE_RECEIPT_UPDATE
+        assert payload.data[0].key.id == message_key_data["id"]
+        assert payload.data[0].receipt.status == receipt_data["status"]
 
     def test_parses_messages_reaction_event_correctly_model(self):
         reaction_key_data = {"remoteJid": "[email protected]", "id": "REACTION_ID", "fromMe": False}
         reaction_data = {"text": "👍", "key": reaction_key_data}
         message_key_data = {"remoteJid": "[email protected]", "id": "MSG_ID", "fromMe": True}
         messages_reaction_data_entry = {"key": message_key_data, "reaction": reaction_data}
         payload = {
-            "type": WebhookEventType.MESSAGES_REACTION.value,
+            "event": WebhookEventType.MESSAGES_REACTION.value,
             "timestamp": 1633456789,
             "data": [messages_reaction_data_entry]
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.MESSAGES_REACTION
-        assert evt.data[0].key.id == message_key_data["id"]
-        assert evt.data[0].reaction.text == reaction_data["text"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.MESSAGES_REACTION
+        assert payload.data[0].key.id == message_key_data["id"]
+        assert payload.data[0].reaction.text == reaction_data["text"]
 
     def test_parses_session_status_event_correctly_model(self):
         session_status_data = {"status": "CONNECTED", "reason": "User initiated connection"}
         payload = {
-            "type": WebhookEventType.SESSION_STATUS.value,
+            "event": WebhookEventType.SESSION_STATUS.value,
             "timestamp": 1633456789,
             "data": session_status_data
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.SESSION_STATUS
-        assert evt.data.status == session_status_data["status"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.SESSION_STATUS
+        assert payload.data.status == session_status_data["status"]
 
     def test_parses_qr_code_updated_event_correctly_model(self):
         qr_code_updated_data = {"qr": "new_qr_code_string", "sessionId": "123-456-789"}
         payload = {
-            "type": WebhookEventType.QRCODE_UPDATED.value,
+            "event": WebhookEventType.QRCODE_UPDATED.value,
             "timestamp": 1633456789,
             "data": qr_code_updated_data
         }
         adapter = TypeAdapter(WasenderWebhookEvent)
-        evt = adapter.validate_python(payload)
-        assert evt.type == WebhookEventType.QRCODE_UPDATED
-        assert evt.data.qr == qr_code_updated_data["qr"]
-        assert evt.data.session_id == qr_code_updated_data["sessionId"]
+        payload = adapter.validate_python(payload)
+        assert payload.event == WebhookEventType.QRCODE_UPDATED
+        assert payload.data.qr == qr_code_updated_data["qr"]
+        assert payload.data.session_id == qr_code_updated_data["sessionId"]
 
 # Client specific fixtures and tests - REMOVED
 # @pytest.fixture

tests/test_webhooks.py

@@ -1 +1 @@
-__version__ = "0.2.4" 
+__version__ = "0.2.5"