test(django): replace flawed exception tests with correct ones

Previous tests didn't properly demonstrate the real Django flow where view exceptions are caught by Django and passed to process_exception.

test_sync_middleware_exception_capture made get_response raise directly, which the context manager caught - doesn't test the real issue where Django catches view exceptions before they reach the middleware.

test_process_exception_integration just called process_exception and asserted it was called - circular logic.

New tests properly simulate Django's behavior:
- test_view_exceptions_only_captured_via_process_exception: proves context manager can't see view exceptions, only process_exception captures them
- test_process_exception_called_during_view_exception: simulates complete Django flow
- test_process_exception_respects_capture_exceptions_false: verifies settings respected
- test_process_exception_respects_request_filter: verifies request filter respected

These tests would have caught the v6.7.5 regression where process_exception was removed.

Author: webjunkie

posthog/test/integrations/test_middleware.py

@@ -201,6 +201,88 @@ def extra_tags_func(request):
 
         self.assertEqual(tags["$request_method"], "PATCH")
 
+    def test_process_exception_called_during_view_exception(self):
+        """
+        Unit test verifying process_exception captures exceptions per Django's contract.
+
+        Since this is a library test (no Django runtime), we simulate how Django
+        would invoke our middleware in production:
+        1. Middleware.__call__ creates context with request tags
+        2. View raises exception inside get_response
+        3. Django's BaseHandler catches it, calls process_exception, returns error response
+        4. Exception never propagates to middleware's context manager
+
+        We manually call process_exception to simulate Django's behavior - this is
+        the only way to test the hook without a full Django integration test.
+        """
+        mock_client = Mock()
+        view_exception = ValueError("View raised this error")
+        error_response = Mock(status_code=500)
+
+        def mock_get_response(request):
+            # Simulate Django's exception handling: catches view exception,
+            # calls process_exception hook if it exists, returns error response
+            if hasattr(middleware, "process_exception"):
+                middleware.process_exception(request, view_exception)
+            return error_response
+
+        middleware = self.create_middleware(get_response=mock_get_response)
+        middleware.client = mock_client
+
+        request = MockRequest(
+            headers={"X-POSTHOG-DISTINCT-ID": "test-user"},
+            method="POST",
+            path="/api/endpoint",
+        )
+        response = middleware(request)
+
+        self.assertEqual(response.status_code, 500)
+        mock_client.capture_exception.assert_called_once_with(view_exception)
+
+    def test_process_exception_respects_capture_exceptions_false(self):
+        """Verify process_exception respects capture_exceptions=False setting"""
+        mock_client = Mock()
+
+        middleware = self.create_middleware(capture_exceptions=False)
+        middleware.client = mock_client
+
+        view_exception = ValueError("Should not be captured")
+
+        def mock_get_response(request):
+            if hasattr(middleware, "process_exception"):
+                middleware.process_exception(request, view_exception)
+            return Mock(status_code=500)
+
+        middleware._sync_get_response = mock_get_response
+
+        request = MockRequest()
+        middleware(request)
+
+        mock_client.capture_exception.assert_not_called()
+
+    def test_process_exception_respects_request_filter(self):
+        """Verify process_exception respects request_filter setting"""
+        mock_client = Mock()
+
+        middleware = self.create_middleware(
+            request_filter=lambda req: False, capture_exceptions=True
+        )
+        middleware.client = mock_client
+
+        view_exception = ValueError("Should be filtered")
+
+        def mock_get_response(request):
+            if hasattr(middleware, "process_exception"):
+                middleware.process_exception(request, view_exception)
+            return Mock(status_code=500)
+
+        middleware._sync_get_response = mock_get_response
+
+        request = MockRequest()
+        middleware(request)
+
+        mock_client.capture_exception.assert_not_called()
+
 
 class TestPosthogContextMiddlewareSync(unittest.TestCase):
     """Test synchronous middleware behavior"""
@@ -250,71 +332,52 @@ def test_sync_middleware_with_filter(self):
         self.assertEqual(response, mock_response)
         get_response.assert_called_once_with(request)
 
-    def test_sync_middleware_exception_capture(self):
-        """Test that sync middleware captures exceptions during request processing"""
-        mock_client = Mock()
-
-        # Make get_response raise an exception
-        def raise_exception(request):
-            raise ValueError("Test exception")
-
-        get_response = Mock(side_effect=raise_exception)
-
-        # Properly initialize middleware
-        middleware = PosthogContextMiddleware(get_response)
-        middleware.client = mock_client  # Override with mock client
-
-        request = MockRequest()
-
-        # Should capture exception and re-raise
-        with self.assertRaises(ValueError):
-            middleware(request)
-
-        # Verify exception was captured by middleware
-        mock_client.capture_exception.assert_called_once()
-        captured_exception = mock_client.capture_exception.call_args[0][0]
-        self.assertIsInstance(captured_exception, ValueError)
-        self.assertEqual(str(captured_exception), "Test exception")
-
-    def test_process_exception_integration(self):
+    def test_view_exceptions_only_captured_via_process_exception(self):
         """
-        Integration test simulating Django's actual exception handling flow.
+        Demonstrates that process_exception is required to capture view exceptions.
 
-        When a view raises an exception:
-        1. Middleware.__call__ creates context with request tags
-        2. __call__ calls self.get_response(request)
-        3. Inside Django's handler: catches exception, checks if middleware.process_exception
-           exists (hasattr), calls it if present, returns error response
-        4. Context manager exits
+        In production Django, view exceptions don't propagate to middleware's context
+        manager because Django's BaseHandler catches them first and converts them to
+        error responses. Django provides the exception via process_exception hook instead.
 
-        This verifies exception capture works in the real Django flow.
+        This unit test proves:
+        1. Context manager in __call__ never sees view exceptions (Django intercepts)
+        2. Only process_exception can capture them
+        3. Without process_exception, exceptions are silently lost (v6.7.5 regression)
+
+        We manually call process_exception to verify the hook works - in production,
+        Django's BaseHandler would call it when a view raises.
         """
         mock_client = Mock()
+        get_response = Mock(return_value=Mock(status_code=500))
 
-        get_response = Mock(return_value=Mock())
         middleware = PosthogContextMiddleware(get_response)
         middleware.client = mock_client
 
-        view_exception = ValueError("View error")
-        error_response = Mock(status_code=500)
+        def get_response_simulating_django(request):
+            # Simulates Django behavior: view exception converted to error response,
+            # never propagates to middleware's context manager
+            return Mock(status_code=500)
 
-        def mock_get_response(request):
-            # Simulate Django: check if process_exception exists, call it
-            if hasattr(middleware, "process_exception"):
-                middleware.process_exception(request, view_exception)
-            return error_response
+        middleware._sync_get_response = get_response_simulating_django
 
-        middleware.get_response = mock_get_response
+        request = MockRequest()
 
-        request = MockRequest(
-            headers={"X-POSTHOG-DISTINCT-ID": "user123"},
-            method="POST",
-            path="/api/test",
-        )
         response = middleware(request)
-
-        self.assertEqual(response, error_response)
-        mock_client.capture_exception.assert_called_once_with(view_exception)
+        self.assertEqual(response.status_code, 500)
+
+        # Context manager didn't capture anything - exception was intercepted by Django
+        mock_client.capture_exception.assert_not_called()
+
+        # Verify process_exception hook exists and captures exceptions when called
+        if hasattr(middleware, "process_exception"):
+            exception = ValueError("View error")
+            middleware.process_exception(request, exception)
+            mock_client.capture_exception.assert_called_once_with(exception)
+        else:
+            self.fail(
+                "process_exception missing - view exceptions will not be captured!"
+            )
 
 
 class TestPosthogContextMiddlewareAsync(unittest.TestCase):