test(django5): improve test quality and cleanup

Apply pytest best practices to Django 5 test suite:
- Add session-scoped asgi_app fixture to share app instance across tests
- Replace print() statements with assertions for cleaner test output
- Use pytest.skip() instead of print+return for skipped tests
- Add @pytest.mark.django_db(transaction=True) for authenticated user test
- Remove if __name__ == "__main__" blocks in favor of pytest runner
- Add pytest-django dependency to properly recognize django_db marker
- Fix mock patch target to 'posthog.capture_exception' (module level)

All 7 tests pass with proper pytest output.

Author: webjunkie

test_project_django5/pyproject.toml

@@ -8,6 +8,7 @@ dependencies = [
     "posthog",
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
+    "pytest-django>=4.0",
     "httpx>=0.27",
 ]
 

test_project_django5/test_exception_capture.py

@@ -18,11 +18,16 @@
 import pytest
 from httpx import AsyncClient, ASGITransport
 from django.core.asgi import get_asgi_application
-from posthog import Client
+
+
+@pytest.fixture(scope="session")
+def asgi_app():
+    """Shared ASGI application for all tests."""
+    return get_asgi_application()
 
 
 @pytest.mark.asyncio
-async def test_async_exception_is_captured():
+async def test_async_exception_is_captured(asgi_app):
     """
     Test that async view exceptions are captured to PostHog.
 
@@ -42,9 +47,9 @@ def mock_capture(exception, **kwargs):
             'message': str(exception)
         })
 
+    # Patch at the posthog module level where middleware imports from
     with patch('posthog.capture_exception', side_effect=mock_capture):
-        app = get_asgi_application()
-        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+        async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
             response = await ac.get("/test/async-exception")
 
         # Django returns 500
@@ -58,13 +63,9 @@ def mock_capture(exception, **kwargs):
         assert exception_data['type'] == 'ValueError'
         assert 'Test exception from Django 5 async view' in exception_data['message']
 
-        print(f"✓ Async exception captured: {len(captured)} exception event(s)")
-        print(f"  Exception type: {exception_data['type']}")
-        print(f"  Exception message: {exception_data['message']}")
-
 
 @pytest.mark.asyncio
-async def test_sync_exception_is_captured():
+async def test_sync_exception_is_captured(asgi_app):
     """
     Test that sync view exceptions are captured to PostHog.
 
@@ -84,9 +85,9 @@ def mock_capture(exception, **kwargs):
             'message': str(exception)
         })
 
+    # Patch at the posthog module level where middleware imports from
     with patch('posthog.capture_exception', side_effect=mock_capture):
-        app = get_asgi_application()
-        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+        async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
             response = await ac.get("/test/sync-exception")
 
         # Django returns 500
@@ -99,33 +100,3 @@ def mock_capture(exception, **kwargs):
         exception_data = captured[0]
         assert exception_data['type'] == 'ValueError'
         assert 'Test exception from Django 5 sync view' in exception_data['message']
-
-        print(f"✓ Sync exception captured: {len(captured)} exception event(s)")
-        print(f"  Exception type: {exception_data['type']}")
-        print(f"  Exception message: {exception_data['message']}")
-
-
-if __name__ == "__main__":
-    """Run tests directly."""
-    import asyncio
-
-    async def run_tests():
-        print("\nTesting exception capture with process_exception() fix...\n")
-
-        try:
-            await test_async_exception_is_captured()
-        except AssertionError as e:
-            print(f"✗ Async exception capture failed: {e}")
-        except Exception as e:
-            print(f"✗ Async test error: {e}")
-
-        try:
-            await test_sync_exception_is_captured()
-        except AssertionError as e:
-            print(f"✗ Sync exception capture failed: {e}")
-        except Exception as e:
-            print(f"✗ Sync test error: {e}")
-
-        print("\nDone!\n")
-
-    asyncio.run(run_tests())

test_project_django5/test_middleware.py

@@ -20,8 +20,14 @@
 from django.core.asgi import get_asgi_application
 
 
+@pytest.fixture(scope="session")
+def asgi_app():
+    """Shared ASGI application for all tests."""
+    return get_asgi_application()
+
+
 @pytest.mark.asyncio
-async def test_async_user_access():
+async def test_async_user_access(asgi_app):
     """
     Test that middleware can access request.user in async context.
 
@@ -32,19 +38,18 @@ async def test_async_user_access():
     trigger the lazy loading bug. This test verifies the middleware works
     in the common case.
     """
-    app = get_asgi_application()
-    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+    async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
         response = await ac.get("/test/async-user")
 
     assert response.status_code == 200
     data = response.json()
     assert data["status"] == "success"
     assert "django_version" in data
-    print(f"✓ Async user access test passed: {data['message']}")
 
 
+@pytest.mark.django_db(transaction=True)
 @pytest.mark.asyncio
-async def test_async_authenticated_user_access():
+async def test_async_authenticated_user_access(asgi_app):
     """
     Test that middleware can access an authenticated user in async context.
 
@@ -91,14 +96,12 @@ def create_session():
     session_cookie = await create_session()
 
     if not session_cookie:
-        print("⚠ Warning: Could not create authenticated session, skipping auth test")
-        return
+        pytest.skip("Could not create authenticated session")
 
     # Make request with session cookie - this should trigger the bug in v6.7.11
     # Disable exception capture to see the SynchronousOnlyOperation clearly
     with override_settings(POSTHOG_MW_CAPTURE_EXCEPTIONS=False):
-        app = get_asgi_application()
-        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+        async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
             response = await ac.get(
                 "/test/async-user",
                 cookies={"sessionid": session_cookie.value}
@@ -108,28 +111,25 @@ def create_session():
         data = response.json()
         assert data["status"] == "success"
         assert data["user_authenticated"] == True
-        print(f"✓ Async authenticated user access test passed: {data['message']}")
 
 
 @pytest.mark.asyncio
-async def test_sync_user_access():
+async def test_sync_user_access(asgi_app):
     """
     Test that middleware works with sync views.
 
     This should always work regardless of middleware version.
     """
-    app = get_asgi_application()
-    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+    async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
         response = await ac.get("/test/sync-user")
 
     assert response.status_code == 200
     data = response.json()
     assert data["status"] == "success"
-    print(f"✓ Sync user access test passed: {data['message']}")
 
 
 @pytest.mark.asyncio
-async def test_async_exception_capture():
+async def test_async_exception_capture(asgi_app):
     """
     Test that middleware handles exceptions from async views.
 
@@ -138,59 +138,23 @@ async def test_async_exception_capture():
     causes a 500 response. See test_exception_capture.py for tests that verify
     actual exception capture to PostHog.
     """
-    app = get_asgi_application()
-    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+    async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
         response = await ac.get("/test/async-exception")
 
     # Django returns 500 for unhandled exceptions
     assert response.status_code == 500
-    print("✓ Async exception raises 500 (captured via process_exception)")
 
 
 @pytest.mark.asyncio
-async def test_sync_exception_capture():
+async def test_sync_exception_capture(asgi_app):
     """
     Test that middleware handles exceptions from sync views.
 
     The middleware's process_exception() method captures view exceptions to PostHog.
     This test verifies the exception causes a 500 response.
     """
-    app = get_asgi_application()
-    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as ac:
+    async with AsyncClient(transport=ASGITransport(app=asgi_app), base_url="http://testserver") as ac:
         response = await ac.get("/test/sync-exception")
 
     # Django returns 500 for unhandled exceptions
     assert response.status_code == 500
-    print("✓ Sync exception raises 500 (captured via process_exception)")
-
-
-if __name__ == "__main__":
-    """Run tests directly with asyncio for quick testing."""
-    import asyncio
-
-    async def run_all_tests():
-        print("\nRunning PostHog Django middleware tests...\n")
-
-        try:
-            await test_async_user_access()
-        except Exception as e:
-            print(f"✗ Async user access test failed: {e}")
-
-        try:
-            await test_sync_user_access()
-        except Exception as e:
-            print(f"✗ Sync user access test failed: {e}")
-
-        try:
-            await test_async_exception_capture()
-        except Exception as e:
-            print(f"✗ Async exception capture test failed: {e}")
-
-        try:
-            await test_sync_exception_capture()
-        except Exception as e:
-            print(f"✗ Sync exception capture test failed: {e}")
-
-        print("\nAll tests completed!\n")
-
-    asyncio.run(run_all_tests())