refactor: remove external dependencies from all tests

- Convert integration tests to unit tests with proper mocking
- Fix API client tests by mocking HTTP responses
- Fix Postgres client tests by mocking at execute_query level
- Fix SDK client tests with valid JWT token format
- Replace 50+ integration tests with focused unit tests
- Update CI to use test values instead of secrets
- All 225 tests now pass without external dependencies

BREAKING CHANGE: Removed integration tests that required real Supabase instance.
Tests now focus on business logic validation rather than external service integration.

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

Co-Authored-By: Claude <[email protected]>

Author: alexander-zuev

.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(mv:*)"
+    ],
+    "deny": []
+  }
+}

.github/workflows/ci.yaml

@@ -14,10 +14,11 @@ jobs:
   test:
     runs-on: ubuntu-latest
     env:
-      SUPABASE_PROJECT_REF: ${{ secrets.SUPABASE_PROJECT_REF }}
-      SUPABASE_DB_PASSWORD: ${{ secrets.SUPABASE_DB_PASSWORD }}
-      SUPABASE_ACCESS_TOKEN: ${{ secrets.SUPABASE_ACCESS_TOKEN }}
-      SUPABASE_SERVICE_ROLE_KEY: ${{ secrets.SUPABASE_SERVICE_ROLE_KEY }}
+      # Test environment variables - no real secrets needed anymore
+      SUPABASE_PROJECT_REF: "abcdefghij1234567890"
+      SUPABASE_DB_PASSWORD: "test-password-123"
+      SUPABASE_ACCESS_TOKEN: "test-access-token"
+      SUPABASE_SERVICE_ROLE_KEY: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
     steps:
       - uses: actions/checkout@v4
 

tests/services/api/test_api_client.py

@@ -1,42 +1,67 @@
 import httpx
 import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
 
 from supabase_mcp.clients.management_client import ManagementAPIClient
 from supabase_mcp.exceptions import APIClientError, APIConnectionError
+from supabase_mcp.settings import Settings
 
 
 @pytest.mark.asyncio(loop_scope="module")
-@pytest.mark.integration
 class TestAPIClient:
-    """Integration tests for the API client."""
-
-    async def test_execute_get_request(self, api_client_integration: ManagementAPIClient):
+    """Unit tests for the API client."""
+
+    @pytest.fixture
+    def mock_settings(self):
+        """Create mock settings for testing."""
+        settings = MagicMock(spec=Settings)
+        settings.supabase_access_token = "test-token"
+        settings.supabase_project_ref = "test-project-ref"
+        settings.supabase_region = "us-east-1"
+        settings.query_api_url = "https://api.test.com"
+        settings.supabase_api_url = "https://api.supabase.com"
+        return settings
+
+    async def test_execute_get_request(self, mock_settings):
         """Test executing a GET request to the API."""
-        # Make a simple GET request to a public endpoint
-        # Since /v1/health returns 404, we'll test the error handling instead
-        path = "/v1/health"
-
-        # Execute the request and expect a 404 error
-        with pytest.raises(APIClientError) as exc_info:
-            await api_client_integration.execute_request(
-                method="GET",
-                path=path,
-            )
-
-        # Verify the error details
-        assert exc_info.value.status_code == 404
-        assert "Cannot GET /v1/health" in str(exc_info.value)
-
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_request_preparation(self, api_client_integration: ManagementAPIClient):
+        # Create client but don't mock the httpx client yet
+        client = ManagementAPIClient(settings=mock_settings)
+        
+        # Setup mock response
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = 404
+        mock_response.is_success = False
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.json.return_value = {"message": "Cannot GET /v1/health"}
+        mock_response.text = '{"message": "Cannot GET /v1/health"}'
+        mock_response.content = b'{"message": "Cannot GET /v1/health"}'
+        
+        # Mock the send_request method to return our mock response
+        with patch.object(client, 'send_request', return_value=mock_response):
+            path = "/v1/health"
+            
+            # Execute the request and expect a 404 error
+            with pytest.raises(APIClientError) as exc_info:
+                await client.execute_request(
+                    method="GET",
+                    path=path,
+                )
+            
+            # Verify the error details
+            assert exc_info.value.status_code == 404
+            assert "Cannot GET /v1/health" in str(exc_info.value)
+
+    async def test_request_preparation(self, mock_settings):
         """Test that requests are properly prepared with headers and parameters."""
+        client = ManagementAPIClient(settings=mock_settings)
+        
         # Prepare a request with parameters
         method = "GET"
         path = "/v1/health"
         request_params = {"param1": "value1", "param2": "value2"}
 
         # Prepare the request
-        request = api_client_integration.prepare_request(
+        request = client.prepare_request(
             method=method,
             path=path,
             request_params=request_params,
@@ -50,37 +75,44 @@ async def test_request_preparation(self, api_client_integration: ManagementAPICl
         assert "Content-Type" in request.headers
         assert request.headers["Content-Type"] == "application/json"
 
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_error_handling(self, api_client_integration: ManagementAPIClient):
+    async def test_error_handling(self, mock_settings):
         """Test handling of API errors."""
-        # Make a request to a non-existent endpoint
-        path = "/v1/nonexistent-endpoint"
-
-        # Execute the request and expect an APIClientError (not APIResponseError)
-        with pytest.raises(APIClientError) as exc_info:
-            await api_client_integration.execute_request(
-                method="GET",
-                path=path,
-            )
-
-        # Verify the error details
-        assert exc_info.value.status_code == 404
-        assert "Cannot GET /v1/nonexistent-endpoint" in str(exc_info.value)
-
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_request_with_body(self, api_client_integration: ManagementAPIClient):
+        client = ManagementAPIClient(settings=mock_settings)
+        
+        # Setup mock response
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = 404
+        mock_response.is_success = False
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.json.return_value = {"message": "Cannot GET /v1/nonexistent-endpoint"}
+        mock_response.text = '{"message": "Cannot GET /v1/nonexistent-endpoint"}'
+        mock_response.content = b'{"message": "Cannot GET /v1/nonexistent-endpoint"}'
+        
+        with patch.object(client, 'send_request', return_value=mock_response):
+            path = "/v1/nonexistent-endpoint"
+            
+            # Execute the request and expect an APIClientError
+            with pytest.raises(APIClientError) as exc_info:
+                await client.execute_request(
+                    method="GET",
+                    path=path,
+                )
+            
+            # Verify the error details
+            assert exc_info.value.status_code == 404
+            assert "Cannot GET /v1/nonexistent-endpoint" in str(exc_info.value)
+
+    async def test_request_with_body(self, mock_settings):
         """Test executing a request with a body."""
-        # This test would normally make a POST request with a body
-        # Since we don't want to create real resources, we'll use a mock
-        # or a safe endpoint that accepts POST but doesn't modify anything
-
-        # For now, we'll just test the request preparation
+        client = ManagementAPIClient(settings=mock_settings)
+        
+        # Test the request preparation
         method = "POST"
-        path = "/v1/health/check"  # This is a hypothetical endpoint
+        path = "/v1/health/check"
         request_body = {"test": "data", "nested": {"value": 123}}
 
         # Prepare the request
-        request = api_client_integration.prepare_request(
+        request = client.prepare_request(
             method=method,
             path=path,
             request_body=request_body,
@@ -93,56 +125,64 @@ async def test_request_with_body(self, api_client_integration: ManagementAPIClie
         assert "Content-Type" in request.headers
         assert request.headers["Content-Type"] == "application/json"
 
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_response_parsing(self, api_client_integration: ManagementAPIClient):
+    async def test_response_parsing(self, mock_settings):
         """Test parsing API responses."""
-        # Make a request to a public endpoint that returns JSON
-        path = "/v1/projects"
-
-        # Execute the request
-        response = await api_client_integration.execute_request(
-            method="GET",
-            path=path,
-        )
-
-        # Verify the response is parsed correctly
-        assert isinstance(response, list)
-        # The response is a list of projects, not a dict with a "projects" key
-        assert len(response) > 0
-        assert "id" in response[0]
-
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_request_retry_mechanism(self, monkeypatch, api_client_integration: ManagementAPIClient):
-        """Test that the tenacity retry mechanism works correctly for API requests."""
-
-        # Create a simple mock that always raises a network error
-        async def mock_send(*args, **kwargs):
-            raise httpx.NetworkError("Simulated network failure", request=None)
-
-        # Replace the client's send method with our mock
-        monkeypatch.setattr(api_client_integration.client, "send", mock_send)
-
-        # Execute a request - this should trigger retries and eventually fail
-        with pytest.raises(APIConnectionError) as exc_info:
-            await api_client_integration.execute_request(
+        client = ManagementAPIClient(settings=mock_settings)
+        
+        # Setup mock response
+        mock_response = MagicMock(spec=httpx.Response)
+        mock_response.status_code = 200
+        mock_response.is_success = True
+        mock_response.headers = {"content-type": "application/json"}
+        mock_response.json.return_value = [{"id": "project1", "name": "Test Project"}]
+        mock_response.content = b'[{"id": "project1", "name": "Test Project"}]'
+        
+        with patch.object(client, 'send_request', return_value=mock_response):
+            path = "/v1/projects"
+            
+            # Execute the request
+            response = await client.execute_request(
                 method="GET",
-                path="/v1/projects",
+                path=path,
             )
+            
+            # Verify the response is parsed correctly
+            assert isinstance(response, list)
+            assert len(response) > 0
+            assert "id" in response[0]
 
-        # Verify the error message indicates retries were attempted
-        assert "Network error after 3 retry attempts" in str(exc_info.value)
-
-    # @pytest.mark.asyncio(loop_scope="function")
-    async def test_request_without_access_token(
-        self, monkeypatch: pytest.MonkeyPatch, api_client_integration: ManagementAPIClient
-    ):
+    async def test_request_retry_mechanism(self, mock_settings):
+        """Test that the tenacity retry mechanism works correctly for API requests."""
+        client = ManagementAPIClient(settings=mock_settings)
+        
+        # Create a mock request object for the NetworkError
+        mock_request = MagicMock(spec=httpx.Request)
+        mock_request.method = "GET"
+        mock_request.url = "https://api.supabase.com/v1/projects"
+        
+        # Mock the client's send method to always raise a network error
+        with patch.object(client.client, 'send', side_effect=httpx.NetworkError("Simulated network failure", request=mock_request)):
+            # Execute a request - this should trigger retries and eventually fail
+            with pytest.raises(APIConnectionError) as exc_info:
+                await client.execute_request(
+                    method="GET",
+                    path="/v1/projects",
+                )
+            
+            # Verify the error message indicates retries were attempted
+            assert "Network error after 3 retry attempts" in str(exc_info.value)
+
+    async def test_request_without_access_token(self, mock_settings):
         """Test that an exception is raised when attempting to send a request without an access token."""
-        # Temporarily set the access token to None
-        monkeypatch.setattr(api_client_integration.settings, "supabase_access_token", None)
+        # Create client with no access token
+        mock_settings.supabase_access_token = None
+        client = ManagementAPIClient(settings=mock_settings)
 
         # Attempt to execute a request - should raise an exception
-        with pytest.raises(APIClientError):
-            await api_client_integration.execute_request(
+        with pytest.raises(APIClientError) as exc_info:
+            await client.execute_request(
                 method="GET",
                 path="/v1/projects",
             )
+        
+        assert "Supabase access token is not configured" in str(exc_info.value)