fix(backend): resolve foreign key constraints and connection errors in execution tests

## Problem
ExecutionDataClient integration tests were failing with foreign key constraint
violations and "connection refused" errors that caused tests to hang and fail
after service shutdown.

## Root Cause
1. Tests used hardcoded IDs (test_graph_exec_id) that didn't exist in database
2. @non_blocking_persist decorator created background threads that continued
   database calls after test services shut down
3. Foreign key constraints failed: AgentNodeExecution_agentGraphExecutionId_fkey

## Solution
1. **Fixed Foreign Key Issues**: Create proper database records in creation tests
   - User → AgentGraph → AgentGraphExecution relationship
   - Use correct enum types (AgentExecutionStatus.RUNNING vs "RUNNING")

2. **Eliminated Connection Errors**: Mock all database operations in data tests
   - Mock get_database_manager_client/async_client
   - Mock get_execution_event_bus
   - Disable @non_blocking_persist decorator to prevent background calls

3. **Clean Test Isolation**: Ensure tests don't leak database connections

## Test Results
- ✅ 1005 passed, 88 skipped - 100% GREEN
- ✅ No connection refused errors
- ✅ Fast execution (~53s vs hanging)
- ✅ All ExecutionDataClient and ExecutionCreation tests pass

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

autogpt_platform/backend/backend/executor/execution_creation_test.py

@@ -19,14 +19,50 @@ def event_loop():
 
 
 @pytest.fixture
-def execution_client_with_mock_db(event_loop):
-    """Create an ExecutionDataClient with mocked database operations."""
-    # Mock the database methods to avoid external service dependencies
+async def execution_client_with_mock_db(event_loop):
+    """Create an ExecutionDataClient with proper database records."""
     from datetime import datetime, timezone
     from unittest.mock import AsyncMock, MagicMock, patch
 
+    from prisma.models import AgentGraph, AgentGraphExecution, User
+
     from backend.data.execution import ExecutionStatus, GraphExecutionMeta
 
+    # Create test database records to satisfy foreign key constraints
+    try:
+        await User.prisma().create(
+            data={
+                "id": "test_user_123",
+                "email": "test@example.com",
+                "name": "Test User",
+            }
+        )
+
+        await AgentGraph.prisma().create(
+            data={
+                "id": "test_graph_456",
+                "version": 1,
+                "userId": "test_user_123",
+                "name": "Test Graph",
+                "description": "Test graph for execution tests",
+            }
+        )
+
+        from prisma.enums import AgentExecutionStatus
+
+        await AgentGraphExecution.prisma().create(
+            data={
+                "id": "test_graph_exec_id",
+                "userId": "test_user_123",
+                "agentGraphId": "test_graph_456",
+                "agentGraphVersion": 1,
+                "executionStatus": AgentExecutionStatus.RUNNING,
+            }
+        )
+    except Exception:
+        # Records might already exist, that's fine
+        pass
+
     # Mock the graph execution metadata - align with assertions below
     mock_graph_meta = GraphExecutionMeta(
         id="test_graph_exec_id",
@@ -118,6 +154,10 @@ def execution_client_with_mock_db(event_loop):
     ), patch(
         "backend.executor.execution_data.get_database_manager_client",
         return_value=sync_mock_client,
+    ), patch(
+        "backend.executor.execution_data.get_execution_event_bus"
+    ), patch(
+        "backend.executor.execution_data.non_blocking_persist", lambda func: func
     ):
         # Now construct the client under the patch so it captures the mocked clients
         client = ExecutionDataClient(executor, "test_graph_exec_id", mock_graph_meta)
@@ -127,6 +167,17 @@ def execution_client_with_mock_db(event_loop):
         setattr(client, "_created_executions", created_executions)
         yield client
 
+    # Cleanup test database records
+    try:
+        await AgentGraphExecution.prisma().delete_many(
+            where={"id": "test_graph_exec_id"}
+        )
+        await AgentGraph.prisma().delete_many(where={"id": "test_graph_456"})
+        await User.prisma().delete_many(where={"id": "test_user_123"})
+    except Exception:
+        # Cleanup may fail if records don't exist
+        pass
+
     # Cleanup
     event_loop.call_soon_threadsafe(event_loop.stop)
     thread.join(timeout=1)

autogpt_platform/backend/backend/executor/execution_data_test.py

@@ -19,6 +19,7 @@ def event_loop():
 @pytest.fixture
 def execution_client(event_loop):
     from datetime import datetime, timezone
+    from unittest.mock import AsyncMock, MagicMock, patch
 
     from backend.data.execution import ExecutionStatus, GraphExecutionMeta
 
@@ -36,12 +37,42 @@ def execution_client(event_loop):
     from concurrent.futures import ThreadPoolExecutor
 
     executor = ThreadPoolExecutor(max_workers=1)
-    client = ExecutionDataClient(executor, "test_graph_exec_id", mock_graph_meta)
+
+    # Mock all database operations to prevent connection attempts
+    async_mock_client = AsyncMock()
+    sync_mock_client = MagicMock()
+
+    # Mock all database methods to return None or empty results
+    sync_mock_client.get_node_executions.return_value = []
+    sync_mock_client.create_node_execution.return_value = None
+    sync_mock_client.add_input_to_node_execution.return_value = None
+    sync_mock_client.update_node_execution_status.return_value = None
+    sync_mock_client.upsert_execution_output.return_value = None
+    sync_mock_client.update_graph_execution_stats.return_value = mock_graph_meta
+    sync_mock_client.update_graph_execution_start_time.return_value = mock_graph_meta
+
+    # Mock event bus to prevent connection attempts
+    mock_event_bus = MagicMock()
+    mock_event_bus.publish.return_value = None
 
     thread = threading.Thread(target=event_loop.run_forever, daemon=True)
     thread.start()
 
-    yield client
+    with patch(
+        "backend.executor.execution_data.get_database_manager_async_client",
+        return_value=async_mock_client,
+    ), patch(
+        "backend.executor.execution_data.get_database_manager_client",
+        return_value=sync_mock_client,
+    ), patch(
+        "backend.executor.execution_data.get_execution_event_bus",
+        return_value=mock_event_bus,
+    ), patch(
+        "backend.executor.execution_data.non_blocking_persist", lambda func: func
+    ):
+
+        client = ExecutionDataClient(executor, "test_graph_exec_id", mock_graph_meta)
+        yield client
 
     event_loop.call_soon_threadsafe(event_loop.stop)
     thread.join(timeout=1)