mcp-security-framework 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

tests/test_examples/test_fastapi_example.py

@@ -17,25 +17,38 @@ Version: 1.0.0
 License: MIT
 """
 
-import os
 import json
-import pytest
+import os
 import tempfile
-from unittest.mock import Mock, patch, MagicMock
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
 from fastapi.testclient import TestClient
 
 from mcp_security_framework.examples.fastapi_example import FastAPISecurityExample
-from mcp_security_framework.schemas.models import AuthResult, AuthStatus, AuthMethod, ValidationResult, ValidationStatus
-from mcp_security_framework.schemas.config import SecurityConfig, AuthConfig, SSLConfig, PermissionConfig, RateLimitConfig
+from mcp_security_framework.schemas.config import (
+    AuthConfig,
+    PermissionConfig,
+    RateLimitConfig,
+    SecurityConfig,
+    SSLConfig,
+)
+from mcp_security_framework.schemas.models import (
+    AuthMethod,
+    AuthResult,
+    AuthStatus,
+    ValidationResult,
+    ValidationStatus,
+)
 
 
 class TestFastAPISecurityExample:
     """Test suite for FastAPI example implementation."""
-    
+
     def setup_method(self):
         """Set up test fixtures before each test method."""
         self.temp_dir = tempfile.mkdtemp()
-        
+
         # Create test configuration
         self.test_config = {
             "environment": "test",
@@ -46,17 +59,17 @@ class TestFastAPISecurityExample:
                 "methods": ["api_key", "jwt", "certificate"],
                 "api_keys": {
                     "admin_key_123": {"username": "admin", "roles": ["admin"]},
-                    "user_key_456": {"username": "user", "roles": ["user"]}
+                    "user_key_456": {"username": "user", "roles": ["user"]},
                 },
                 "jwt_secret": "test-super-secret-jwt-key-for-testing-purposes-only",
                 "jwt_algorithm": "HS256",
                 "jwt_expiry_hours": 24,
-                "public_paths": ["/health", "/metrics"]
+                "public_paths": ["/health", "/metrics"],
             },
             "permissions": {
                 "enabled": True,
                 "roles_file": "test_roles.json",
-                "default_role": "user"
+                "default_role": "user",
             },
             "ssl": {
                 "enabled": False,
@@ -64,61 +77,68 @@ class TestFastAPISecurityExample:
                 "key_file": None,
                 "ca_cert_file": None,
                 "verify_mode": "CERT_NONE",
-                "min_version": "TLSv1.2"
+                "min_version": "TLSv1.2",
             },
             "certificates": {
                 "enabled": False,
                 "ca_cert_path": None,
                 "ca_key_path": None,
-                "cert_output_dir": None
+                "cert_output_dir": None,
             },
             "rate_limit": {
                 "enabled": True,
                 "requests_per_minute": 100,
                 "burst_limit": 10,
-                "window_seconds": 60
-            }
+                "window_seconds": 60,
+            },
         }
-    
+
     def teardown_method(self):
         """Clean up after each test method."""
         import shutil
+
         shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
+
     def _create_config_file(self) -> str:
         """Create temporary configuration file for testing."""
         config_file = os.path.join(self.temp_dir, "test_config.json")
-        with open(config_file, 'w') as f:
+        with open(config_file, "w") as f:
             json.dump(self.test_config, f)
         return config_file
-    
+
     def test_fastapi_example_initialization(self):
         """Test FastAPI example initialization."""
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
-        
+
         # Assertions
         assert example is not None
         assert example.app is not None
         assert example.config is not None
         assert example.security_manager is not None
-    
+
     def test_fastapi_example_health_endpoint(self):
         """Test health check endpoint."""
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test health endpoint
         response = client.get("/health")
-        
+
         # Assertions
         assert response.status_code == 200
         assert response.json()["status"] == "healthy"
-    
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.authenticate_user')
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.check_permissions')
-    def test_fastapi_example_protected_endpoint_with_api_key(self, mock_check_permissions, mock_authenticate):
+
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.authenticate_user"
+    )
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.check_permissions"
+    )
+    def test_fastapi_example_protected_endpoint_with_api_key(
+        self, mock_check_permissions, mock_authenticate
+    ):
         """Test protected endpoint with API key authentication."""
         # Mock authentication
         mock_authenticate.return_value = AuthResult(
@@ -126,49 +146,53 @@ class TestFastAPISecurityExample:
             status=AuthStatus.SUCCESS,
             username="admin",
             roles=["admin"],
-            auth_method=AuthMethod.API_KEY
+            auth_method=AuthMethod.API_KEY,
         )
-        
+
         # Mock permission check
         mock_check_permissions.return_value = ValidationResult(
-            is_valid=True,
-            status=ValidationStatus.VALID
+            is_valid=True, status=ValidationStatus.VALID
         )
-        
+
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test protected endpoint
         response = client.get(
-            "/api/v1/users/me",
-            headers={"X-API-Key": "admin_key_123"}
+            "/api/v1/users/me", headers={"X-API-Key": "admin_key_123"}
         )
-        
+
         # Assertions
         assert response.status_code == 200
         response_data = response.json()
         assert "user" in response_data
         assert "username" in response_data["user"]
-    
+
     def test_fastapi_example_protected_endpoint_unauthorized(self):
         """Test protected endpoint without authentication."""
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test protected endpoint without auth
         response = client.get("/api/v1/users/me")
-        
+
         # Assertions
         assert response.status_code == 401
-    
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.authenticate_user')
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.check_permissions')
-    @patch('mcp_security_framework.core.rate_limiter.RateLimiter.check_rate_limit')
-    def test_fastapi_example_rate_limiting(self, mock_check_rate_limit, mock_check_permissions, mock_authenticate):
+
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.authenticate_user"
+    )
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.check_permissions"
+    )
+    @patch("mcp_security_framework.core.rate_limiter.RateLimiter.check_rate_limit")
+    def test_fastapi_example_rate_limiting(
+        self, mock_check_rate_limit, mock_check_permissions, mock_authenticate
+    ):
         """Test rate limiting functionality."""
         # Mock authentication
         mock_authenticate.return_value = AuthResult(
@@ -176,57 +200,54 @@ class TestFastAPISecurityExample:
             status=AuthStatus.SUCCESS,
             username="user",
             roles=["user"],
-            auth_method=AuthMethod.API_KEY
+            auth_method=AuthMethod.API_KEY,
         )
-        
+
         # Mock permission check
         mock_check_permissions.return_value = ValidationResult(
-            is_valid=True,
-            status=ValidationStatus.VALID
+            is_valid=True, status=ValidationStatus.VALID
         )
-        
+
         # Mock rate limiting - first 100 requests allowed, then blocked
         request_count = 0
+
         def mock_rate_limit(identifier):
             nonlocal request_count
             request_count += 1
             return request_count <= 100
-        
+
         mock_check_rate_limit.side_effect = mock_rate_limit
-        
+
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test rate limiting
-        response = client.get(
-            "/api/v1/users/me",
-            headers={"X-API-Key": "user_key_456"}
-        )
-        
+        response = client.get("/api/v1/users/me", headers={"X-API-Key": "user_key_456"})
+
         # Assertions
         assert response.status_code == 200
-    
+
     def test_fastapi_example_ssl_configuration(self):
         """Test SSL configuration."""
         # SSL configuration
         ssl_config = self.test_config.copy()
-        ssl_config["ssl"] = {
-            "enabled": False
-        }
-        
+        ssl_config["ssl"] = {"enabled": False}
+
         # Create example
         config_file = os.path.join(self.temp_dir, "ssl_config.json")
-        with open(config_file, 'w') as f:
+        with open(config_file, "w") as f:
             json.dump(ssl_config, f)
-        
+
         example = FastAPISecurityExample(config_path=config_file)
-        
+
         # Assertions
         assert example.app is not None
-    
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.authenticate_user')
+
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.authenticate_user"
+    )
     def test_fastapi_example_error_handling(self, mock_authenticate):
         """Test error handling."""
         # Mock authentication failure
@@ -237,77 +258,80 @@ class TestFastAPISecurityExample:
             roles=[],
             auth_method=None,
             error_code=-32002,
-            error_message="Authentication failed"
+            error_message="Authentication failed",
         )
-        
+
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test error handling
-        response = client.get(
-            "/api/v1/users/me",
-            headers={"X-API-Key": "invalid_key"}
-        )
-        
+        response = client.get("/api/v1/users/me", headers={"X-API-Key": "invalid_key"})
+
         # Assertions
         assert response.status_code == 401
-    
+
     def test_fastapi_example_metrics_endpoint(self):
         """Test metrics endpoint."""
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test metrics endpoint
         response = client.get("/metrics")
-        
+
         # Assertions
         assert response.status_code == 200
         response_data = response.json()
         assert "metrics" in response_data
         assert "authentication_attempts" in response_data["metrics"]
-    
+
     def test_fastapi_example_run_method(self):
         """Test FastAPI example run method."""
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
-        
+
         # Test run method (should not raise exception)
         try:
             # This would normally start a server, but we're just testing the method exists
-            assert hasattr(example, 'run')
+            assert hasattr(example, "run")
         except Exception as e:
             # Expected behavior - server can't start in test environment
             pass
-    
+
     def test_fastapi_example_config_loading(self):
         """Test configuration loading from file."""
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
-        
+
         # Assertions
         assert example.config.environment == "test"
         assert example.config.auth.enabled is True
         assert example.config.ssl.enabled is False
-    
+
     def test_fastapi_example_default_config(self):
         """Test FastAPI example with default configuration."""
         # Use configuration with SSL disabled to avoid certificate file issues
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
-        
+
         # Assertions
         assert example is not None
         assert example.app is not None
         assert example.config is not None
-    
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.authenticate_user')
-    @patch('mcp_security_framework.core.security_manager.SecurityManager.check_permissions')
-    def test_fastapi_example_jwt_authentication(self, mock_check_permissions, mock_authenticate_jwt):
+
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.authenticate_user"
+    )
+    @patch(
+        "mcp_security_framework.core.security_manager.SecurityManager.check_permissions"
+    )
+    def test_fastapi_example_jwt_authentication(
+        self, mock_check_permissions, mock_authenticate_jwt
+    ):
         """Test JWT token authentication."""
         # Mock JWT authentication
         mock_authenticate_jwt.return_value = AuthResult(
@@ -315,47 +339,46 @@ class TestFastAPISecurityExample:
             status=AuthStatus.SUCCESS,
             username="user",
             roles=["user"],
-            auth_method=AuthMethod.JWT
+            auth_method=AuthMethod.JWT,
         )
-        
+
         # Mock permission check
         mock_check_permissions.return_value = ValidationResult(
-            is_valid=True,
-            status=ValidationStatus.VALID
+            is_valid=True, status=ValidationStatus.VALID
         )
-        
+
         # Create example
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test JWT authentication - use a public endpoint that doesn't require auth
         response = client.get("/health")
-        
+
         # Assertions
         assert response.status_code == 200
-    
+
     def test_fastapi_example_cors_configuration(self):
         """Test CORS configuration."""
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test CORS headers - use GET request instead of OPTIONS
         response = client.get("/health")
-        
+
         # Assertions
         assert response.status_code == 200
-    
+
     def test_fastapi_example_security_headers(self):
         """Test security headers configuration."""
         config_file = self._create_config_file()
         example = FastAPISecurityExample(config_path=config_file)
         client = TestClient(example.app)
-        
+
         # Test security headers
         response = client.get("/health")
-        
+
         # Assertions
         assert response.status_code == 200
         # Check that response has headers (basic check)