Merge branch 'main' into feat/gsoc-page

Nachiket-Roy · web-flow · commit 93ce15895c44 · 2025-12-13T15:44:30.000+05:30
diff --git a/.env.example b/.env.example
@@ -31,6 +31,7 @@ SLACK_ID_CLIENT=your_slack_client_id_here
 SLACK_SECRET_CLIENT=your_slack_client_secret_here
 SLACK_BOT_TOKEN=your_slack_bot_token_here
 SLACK_SIGNING_SECRET=your_slack_signing_secret_here
+SLACK_WEBHOOK_URL=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
 
 #BlueSky User Details
 BLUESKY_USERNAME=example.bsky.social
diff --git a/website/tests/test_sendgrid_webhook.py b/website/tests/test_sendgrid_webhook.py
@@ -0,0 +1,210 @@
+import json
+from unittest.mock import patch
+
+from django.contrib.auth.models import User
+from django.test import Client, TestCase
+from django.urls import reverse
+
+from website.models import Domain, UserProfile
+
+
+class SendGridWebhookTestCase(TestCase):
+    """Test SendGrid webhook handling and Slack notification"""
+
+    def setUp(self):
+        """Set up test data"""
+        self.client = Client()
+        self.webhook_url = reverse("inbound_event_webhook_callback")
+
+        # Create test user with email
+        self.user = User.objects.create_user(username="testuser", email="test@example.com", password="testpass")
+        self.user_profile = UserProfile.objects.get(user=self.user)
+
+        # Create test domain
+        self.domain = Domain.objects.create(
+            name="example.com",
+            url="https://example.com",
+            email="test@example.com",
+        )
+
+    @patch("website.views.organization.requests.post")
+    def test_webhook_sends_to_slack_with_bounce_event(self, mock_post):
+        """Test that webhook sends bounce event to Slack"""
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.raise_for_status = lambda: None
+
+        payload = [
+            {
+                "email": "test@example.com",
+                "event": "bounce",
+                "reason": "Invalid mailbox",
+                "timestamp": "2024-01-01 12:00:00",
+                "sg_message_id": "test-message-id",
+            }
+        ]
+
+        with patch.dict("os.environ", {"SLACK_WEBHOOK_URL": "https://hooks.slack.com/test"}):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json()["detail"], "Inbound Sendgrid Webhook received")
+
+        # Verify Slack webhook was called
+        self.assertTrue(mock_post.called)
+        call_args = mock_post.call_args
+        self.assertEqual(call_args[0][0], "https://hooks.slack.com/test")
+
+        # Verify the payload sent to Slack
+        slack_payload = call_args[1]["json"]
+        self.assertIn("blocks", slack_payload)
+        self.assertEqual(len(slack_payload["blocks"]), 1)
+
+        # Verify the message contains event details
+        text = slack_payload["blocks"][0]["text"]["text"]
+        self.assertIn("BOUNCE", text)
+        self.assertIn("test@example.com", text)
+        self.assertIn("Invalid mailbox", text)
+
+    @patch("website.views.organization.requests.post")
+    def test_webhook_sends_to_slack_with_click_event(self, mock_post):
+        """Test that webhook sends click event to Slack"""
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.raise_for_status = lambda: None
+
+        payload = [
+            {
+                "email": "test@example.com",
+                "event": "click",
+                "url": "https://example.com/link",
+                "timestamp": "2024-01-01 12:00:00",
+            }
+        ]
+
+        with patch.dict("os.environ", {"SLACK_WEBHOOK_URL": "https://hooks.slack.com/test"}):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        self.assertEqual(response.status_code, 200)
+
+        # Verify Slack webhook was called
+        self.assertTrue(mock_post.called)
+        slack_payload = mock_post.call_args[1]["json"]
+        text = slack_payload["blocks"][0]["text"]["text"]
+        self.assertIn("CLICK", text)
+        self.assertIn("https://example.com/link", text)
+
+    @patch("website.views.organization.logger")
+    def test_webhook_without_slack_url_logs_debug(self, mock_logger):
+        """Test that webhook logs debug message when SLACK_WEBHOOK_URL is not set"""
+        payload = [
+            {
+                "email": "test@example.com",
+                "event": "open",
+                "timestamp": "2024-01-01 12:00:00",
+            }
+        ]
+
+        with patch.dict("os.environ", {}, clear=True):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        self.assertEqual(response.status_code, 200)
+
+        # Verify debug log was called
+        mock_logger.debug.assert_called_with("SLACK_WEBHOOK_URL not configured, skipping Slack notification")
+
+    @patch("website.views.organization.requests.post")
+    @patch("website.views.organization.logger")
+    def test_webhook_handles_slack_error_gracefully(self, mock_logger, mock_post):
+        """Test that webhook handles Slack errors without failing the webhook"""
+        # Simulate Slack webhook error
+        mock_post.side_effect = Exception("Slack is down")
+
+        payload = [
+            {
+                "email": "test@example.com",
+                "event": "delivered",
+                "timestamp": "2024-01-01 12:00:00",
+            }
+        ]
+
+        with patch.dict("os.environ", {"SLACK_WEBHOOK_URL": "https://hooks.slack.com/test"}):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        # Webhook should still succeed even if Slack fails
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json()["detail"], "Inbound Sendgrid Webhook received")
+
+        # Verify error was logged
+        mock_logger.error.assert_called()
+
+    @patch("website.views.organization.requests.post")
+    def test_webhook_sends_multiple_events_to_slack(self, mock_post):
+        """Test that webhook sends multiple events to Slack"""
+        mock_post.return_value.status_code = 200
+        mock_post.return_value.raise_for_status = lambda: None
+
+        payload = [
+            {
+                "email": "test1@example.com",
+                "event": "delivered",
+                "timestamp": "2024-01-01 12:00:00",
+            },
+            {
+                "email": "test2@example.com",
+                "event": "open",
+                "timestamp": "2024-01-01 12:05:00",
+            },
+        ]
+
+        with patch.dict("os.environ", {"SLACK_WEBHOOK_URL": "https://hooks.slack.com/test"}):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        self.assertEqual(response.status_code, 200)
+
+        # Verify Slack webhook was called twice (once for each event)
+        self.assertEqual(mock_post.call_count, 2)
+
+    def test_webhook_updates_user_profile(self):
+        """Test that webhook still updates user profile as before"""
+        payload = [
+            {
+                "email": "test@example.com",
+                "event": "bounce",
+                "reason": "Invalid mailbox",
+                "timestamp": "2024-01-01 12:00:00",
+            }
+        ]
+
+        with patch.dict("os.environ", {}, clear=True):
+            response = self.client.post(
+                self.webhook_url,
+                data=json.dumps(payload),
+                content_type="application/json",
+            )
+
+        self.assertEqual(response.status_code, 200)
+
+        # Verify user profile was updated
+        self.user_profile.refresh_from_db()
+        self.assertEqual(self.user_profile.email_status, "bounce")
+        self.assertEqual(self.user_profile.email_last_event, "bounce")
+        self.assertEqual(self.user_profile.email_bounce_reason, "Invalid mailbox")
diff --git a/website/views/organization.py b/website/views/organization.py
@@ -1,6 +1,7 @@
 import ipaddress
 import json
 import logging
+import os
 import re
 import time
 from collections import defaultdict
@@ -1184,7 +1185,9 @@ def get_success_url(self):
 class InboundParseWebhookView(View):
     def post(self, request, *args, **kwargs):
         data = request.body
-        for event in json.loads(data):
+        events = json.loads(data)
+
+        for event in events:
             try:
                 # Try to find a matching domain first
                 domain = Domain.objects.filter(email__iexact=event.get("email")).first()
@@ -1222,8 +1225,62 @@ def post(self, request, *args, **kwargs):
             except (Domain.DoesNotExist, User.DoesNotExist, AttributeError, ValueError, json.JSONDecodeError) as e:
                 logger.error(f"Error processing SendGrid webhook event: {str(e)}")
 
+        # Send events to Slack webhook
+        self._send_to_slack(events)
+
         return JsonResponse({"detail": "Inbound Sendgrid Webhook received"})
 
+    def _send_to_slack(self, events):
+        """
+        Send SendGrid webhook events to Slack webhook.
+
+        Args:
+            events: List of SendGrid webhook event dictionaries
+        """
+        try:
+            slack_webhook_url = os.environ.get("SLACK_WEBHOOK_URL")
+
+            if not slack_webhook_url:
+                logger.debug("SLACK_WEBHOOK_URL not configured, skipping Slack notification")
+                return
+
+            # Format events for Slack
+            for event in events:
+                event_type = event.get("event", "unknown")
+                email = event.get("email", "unknown")
+                timestamp = event.get("timestamp", "")
+
+                # Create a formatted message for this event
+                event_text = f"*📧 SendGrid Event: {event_type.upper()}*\n"
+                event_text += f"*Email:* {email}\n"
+                event_text += f"*Timestamp:* {timestamp}\n"
+
+                # Add additional details based on event type
+                if event_type == "bounce":
+                    reason = event.get("reason", "Unknown")
+                    event_text += f"*Reason:* {reason}\n"
+                elif event_type == "click":
+                    url = event.get("url", "N/A")
+                    event_text += f"*URL:* {url}\n"
+
+                # Add any other relevant fields
+                if "sg_message_id" in event:
+                    event_text += f"*Message ID:* {event.get('sg_message_id')}\n"
+
+                # Prepare Slack payload
+                payload = {"blocks": [{"type": "section", "text": {"type": "mrkdwn", "text": event_text}}]}
+
+                # Send to Slack
+                response = requests.post(slack_webhook_url, json=payload, timeout=5)
+                response.raise_for_status()
+
+            logger.info(f"Successfully sent {len(events)} SendGrid event(s) to Slack")
+
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to send SendGrid events to Slack: {str(e)}")
+        except Exception as e:
+            logger.error(f"Unexpected error sending to Slack: {str(e)}")
+
 
 class CreateHunt(TemplateView):
     model = Hunt
