django-cfg 1.4.116__py3-none-any.whl → 1.5.14__py3-none-any.whl

django_cfg/apps/integrations/grpc/testing/examples.py

@@ -0,0 +1,263 @@
+"""
+Example payloads for gRPC method testing.
+
+This registry provides example request payloads and expected responses
+for common gRPC methods. Used by the Testing API to provide interactive
+examples.
+
+To add your own examples, extend the EXAMPLES_REGISTRY dictionary:
+
+    EXAMPLES_REGISTRY['YourService'] = {
+        'YourMethod': {
+            'description': 'Description of what this method does',
+            'payload': {'field': 'value'},
+            'expected_response': {'result': 'value'},
+            'metadata': {'authorization': 'Bearer TOKEN'},
+        }
+    }
+"""
+
+from typing import Any, Dict, Optional
+
+# Global examples registry
+# Structure: {ServiceName: {MethodName: {description, payload, expected_response, metadata}}}
+EXAMPLES_REGISTRY: Dict[str, Dict[str, Dict[str, Any]]] = {
+    # Example: User Service
+    "UserService": {
+        "GetUser": {
+            "description": "Get user by ID",
+            "payload": {"user_id": 123},
+            "expected_response": {
+                "id": 123,
+                "username": "john_doe",
+                "email": "john@example.com",
+                "created_at": "2025-01-01T00:00:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_TOKEN"},
+        },
+        "ListUsers": {
+            "description": "List users with pagination",
+            "payload": {"page": 1, "page_size": 10, "filter": ""},
+            "expected_response": {
+                "users": [
+                    {"id": 1, "username": "user1", "email": "user1@example.com"},
+                    {"id": 2, "username": "user2", "email": "user2@example.com"},
+                ],
+                "total": 25,
+                "page": 1,
+                "page_size": 10,
+            },
+            "metadata": {"authorization": "Bearer YOUR_TOKEN"},
+        },
+        "CreateUser": {
+            "description": "Create a new user",
+            "payload": {
+                "username": "new_user",
+                "email": "new@example.com",
+                "password": "secure_password_123",
+            },
+            "expected_response": {
+                "id": 456,
+                "username": "new_user",
+                "email": "new@example.com",
+                "created_at": "2025-11-03T12:00:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_ADMIN_TOKEN"},
+        },
+        "UpdateUser": {
+            "description": "Update user information",
+            "payload": {
+                "user_id": 123,
+                "username": "updated_username",
+                "email": "updated@example.com",
+            },
+            "expected_response": {
+                "id": 123,
+                "username": "updated_username",
+                "email": "updated@example.com",
+                "updated_at": "2025-11-03T12:00:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_TOKEN"},
+        },
+        "DeleteUser": {
+            "description": "Delete user by ID",
+            "payload": {"user_id": 123},
+            "expected_response": {"success": True, "message": "User deleted"},
+            "metadata": {"authorization": "Bearer YOUR_ADMIN_TOKEN"},
+        },
+    },
+    # Example: Product Service
+    "ProductService": {
+        "GetProduct": {
+            "description": "Get product by ID",
+            "payload": {"product_id": 456},
+            "expected_response": {
+                "id": 456,
+                "name": "Example Product",
+                "price": 29.99,
+                "currency": "USD",
+                "in_stock": True,
+            },
+            "metadata": {},
+        },
+        "ListProducts": {
+            "description": "List products with filters",
+            "payload": {
+                "page": 1,
+                "page_size": 20,
+                "category": "electronics",
+                "min_price": 10.0,
+                "max_price": 100.0,
+            },
+            "expected_response": {
+                "products": [
+                    {
+                        "id": 1,
+                        "name": "Product 1",
+                        "price": 29.99,
+                        "category": "electronics",
+                    }
+                ],
+                "total": 50,
+                "page": 1,
+                "page_size": 20,
+            },
+            "metadata": {},
+        },
+        "CreateProduct": {
+            "description": "Create a new product",
+            "payload": {
+                "name": "New Product",
+                "description": "Product description",
+                "price": 49.99,
+                "currency": "USD",
+                "category": "electronics",
+            },
+            "expected_response": {
+                "id": 789,
+                "name": "New Product",
+                "price": 49.99,
+                "created_at": "2025-11-03T12:00:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_ADMIN_TOKEN"},
+        },
+    },
+    # Example: Order Service
+    "OrderService": {
+        "CreateOrder": {
+            "description": "Create a new order",
+            "payload": {
+                "user_id": 123,
+                "items": [
+                    {"product_id": 456, "quantity": 2, "price": 29.99},
+                    {"product_id": 789, "quantity": 1, "price": 49.99},
+                ],
+                "shipping_address": {
+                    "street": "123 Main St",
+                    "city": "New York",
+                    "country": "USA",
+                    "postal_code": "10001",
+                },
+            },
+            "expected_response": {
+                "order_id": "ORD-2025-001",
+                "status": "pending",
+                "total_amount": 109.97,
+                "currency": "USD",
+                "created_at": "2025-11-03T12:00:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_TOKEN"},
+        },
+        "GetOrder": {
+            "description": "Get order by ID",
+            "payload": {"order_id": "ORD-2025-001"},
+            "expected_response": {
+                "order_id": "ORD-2025-001",
+                "user_id": 123,
+                "status": "delivered",
+                "total_amount": 109.97,
+                "currency": "USD",
+                "items": [
+                    {"product_id": 456, "quantity": 2, "price": 29.99},
+                    {"product_id": 789, "quantity": 1, "price": 49.99},
+                ],
+                "created_at": "2025-11-03T12:00:00Z",
+                "delivered_at": "2025-11-05T15:30:00Z",
+            },
+            "metadata": {"authorization": "Bearer YOUR_TOKEN"},
+        },
+    },
+}
+
+
+def get_example(
+    service_name: str, method_name: str
+) -> Optional[Dict[str, Any]]:
+    """
+    Get example payload for a specific service method.
+
+    Args:
+        service_name: Name of the service (e.g., 'UserService')
+        method_name: Name of the method (e.g., 'GetUser')
+
+    Returns:
+        Example dictionary with payload, expected_response, etc. or None
+
+    Example:
+        >>> example = get_example('UserService', 'GetUser')
+        >>> example['payload']
+        {'user_id': 123}
+    """
+    service_examples = EXAMPLES_REGISTRY.get(service_name)
+    if not service_examples:
+        return None
+
+    method_example = service_examples.get(method_name)
+    return method_example
+
+
+def register_example(
+    service_name: str,
+    method_name: str,
+    description: str,
+    payload: Dict[str, Any],
+    expected_response: Dict[str, Any],
+    metadata: Optional[Dict[str, str]] = None,
+) -> None:
+    """
+    Register a new example for a service method.
+
+    Args:
+        service_name: Name of the service
+        method_name: Name of the method
+        description: Description of what the method does
+        payload: Example request payload
+        expected_response: Example expected response
+        metadata: Optional metadata (headers)
+
+    Example:
+        >>> register_example(
+        ...     'MyService',
+        ...     'MyMethod',
+        ...     'Does something',
+        ...     {'param': 'value'},
+        ...     {'result': 'success'},
+        ...     {'authorization': 'Bearer TOKEN'}
+        ... )
+    """
+    if service_name not in EXAMPLES_REGISTRY:
+        EXAMPLES_REGISTRY[service_name] = {}
+
+    EXAMPLES_REGISTRY[service_name][method_name] = {
+        "description": description,
+        "payload": payload,
+        "expected_response": expected_response,
+        "metadata": metadata or {},
+    }
+
+
+__all__ = [
+    "EXAMPLES_REGISTRY",
+    "get_example",
+    "register_example",
+]

django_cfg/apps/integrations/grpc/urls.py

@@ -0,0 +1,47 @@
+"""
+URL patterns for gRPC module.
+
+Public API endpoints for gRPC monitoring.
+"""
+
+from django.urls import include, path
+from rest_framework import routers
+
+from .views.api_keys import GRPCApiKeyViewSet
+from .views.charts import GRPCChartsViewSet
+from .views.config import GRPCConfigViewSet
+from .views.monitoring import GRPCMonitorViewSet
+from .views.proto_files import GRPCProtoFilesViewSet
+from .views.services import GRPCServiceViewSet
+from .views.testing import GRPCTestingViewSet
+
+app_name = 'django_cfg_grpc'
+
+# Create router
+router = routers.DefaultRouter()
+
+# Monitoring endpoints (Django logs based)
+router.register(r'monitor', GRPCMonitorViewSet, basename='monitor')
+
+# Configuration endpoints
+router.register(r'config', GRPCConfigViewSet, basename='config')
+
+# Service registry endpoints
+router.register(r'services', GRPCServiceViewSet, basename='services')
+
+# Testing endpoints
+router.register(r'test', GRPCTestingViewSet, basename='test')
+
+# Charts endpoints (statistics visualization)
+router.register(r'charts', GRPCChartsViewSet, basename='charts')
+
+# API Keys endpoints (read-only)
+router.register(r'api-keys', GRPCApiKeyViewSet, basename='api-keys')
+
+# Proto Files endpoints (download proto files)
+router.register(r'proto-files', GRPCProtoFilesViewSet, basename='proto-files')
+
+urlpatterns = [
+    # Include router URLs
+    path('', include(router.urls)),
+]

django_cfg/apps/integrations/grpc/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+Utilities for gRPC Integration.
+
+Reusable utilities for gRPC services in django-cfg.
+"""
+
+from .streaming_logger import setup_streaming_logger, get_streaming_logger
+
+__all__ = ["setup_streaming_logger", "get_streaming_logger"]

django_cfg/apps/integrations/grpc/utils/integration_test.py

@@ -0,0 +1,334 @@
+"""
+gRPC Integration Test Utility.
+
+Comprehensive integration test for gRPC with API keys.
+Automatically performs all steps from proto generation to log verification.
+"""
+
+import sys
+import time
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import grpc
+from django.conf import settings
+from django.contrib.auth import get_user_model
+
+from django_cfg.apps.integrations.grpc.models import GrpcApiKey, GRPCRequestLog
+
+User = get_user_model()
+
+
+class GRPCIntegrationTest:
+    """Comprehensive integration test for gRPC with API keys."""
+
+    def __init__(self, app_label: str = "crypto", quiet: bool = False):
+        """
+        Initialize integration test.
+
+        Args:
+            app_label: Django app label to generate protos for
+            quiet: Suppress verbose output
+        """
+        self.app_label = app_label
+        self.quiet = quiet
+        self.server_process: Optional[subprocess.Popen] = None
+        self.api_key: Optional[GrpcApiKey] = None
+        self.grpc_port = settings.GRPC_SERVER.get("port", 50051)
+
+    def log(self, message: str):
+        """Print message if not quiet."""
+        if not self.quiet:
+            print(message)
+
+    def print_step(self, step_num: int, message: str):
+        """Print step with formatting."""
+        if not self.quiet:
+            print(f"\n{'='*70}")
+            print(f"🔹 Step {step_num}: {message}")
+            print(f"{'='*70}")
+
+    def step1_generate_protos(self) -> bool:
+        """Step 1: Generate proto files."""
+        self.print_step(1, f"Generating proto files for {self.app_label}")
+
+        try:
+            result = subprocess.run(
+                [sys.executable, "manage.py", "generate_protos", self.app_label],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            self.log("✅ Proto files generated successfully")
+            return True
+
+        except subprocess.CalledProcessError as e:
+            self.log(f"❌ Proto generation error: {e}")
+            if e.stderr:
+                self.log(f"   STDERR: {e.stderr}")
+            return False
+
+    def step2_start_server(self) -> bool:
+        """Step 2: Start gRPC server."""
+        self.print_step(2, "Starting gRPC server")
+
+        try:
+            self.server_process = subprocess.Popen(
+                [sys.executable, "manage.py", "rungrpc"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+
+            self.log(f"✅ gRPC server started (PID: {self.server_process.pid})")
+            self.log(f"   Port: {self.grpc_port}")
+            self.log("   Waiting for server to start...")
+            time.sleep(3)
+
+            if self.server_process.poll() is not None:
+                stdout, stderr = self.server_process.communicate()
+                self.log(f"❌ Server terminated prematurely")
+                self.log(f"   STDOUT: {stdout}")
+                self.log(f"   STDERR: {stderr}")
+                return False
+
+            self.log("✅ Server is running")
+            return True
+
+        except Exception as e:
+            self.log(f"❌ Server startup error: {e}")
+            return False
+
+    def step3_create_api_key(self) -> bool:
+        """Step 3: Create test API key."""
+        self.print_step(3, "Creating test API key")
+
+        try:
+            user = User.objects.filter(is_active=True).first()
+            if not user:
+                self.log("   Creating test user...")
+                user = User.objects.create_user(
+                    username="grpc_integration_test",
+                    email="grpc_test@example.com",
+                    password="test_password_123",
+                    is_active=True
+                )
+                self.log(f"   ✅ Created user: {user.username}")
+            else:
+                self.log(f"   ✅ Using existing user: {user.username}")
+
+            self.api_key = GrpcApiKey.objects.create_for_user(
+                user=user,
+                name="Integration Test Key",
+                key_type="development",
+                expires_in_days=None,
+            )
+
+            self.log(f"✅ API key created")
+            self.log(f"   Name: {self.api_key.name}")
+            self.log(f"   Key: {self.api_key.key[:32]}...")
+            self.log(f"   User: {self.api_key.user.username}")
+            self.log(f"   Valid: {self.api_key.is_valid}")
+
+            return True
+
+        except Exception as e:
+            self.log(f"❌ API key creation error: {e}")
+            import traceback
+            if not self.quiet:
+                traceback.print_exc()
+            return False
+
+    def step4_test_client(self) -> bool:
+        """Step 4: Test gRPC client."""
+        self.print_step(4, "Testing gRPC client with API key")
+
+        try:
+            import importlib
+            module_path = f"apps.{self.app_label}.grpc_services.generated"
+
+            try:
+                service_name = f"{self.app_label}_service"
+                proto_module = importlib.import_module(f"{module_path}.{service_name}_pb2")
+                grpc_module = importlib.import_module(f"{module_path}.{service_name}_pb2_grpc")
+                service_stub_name = f"{self.app_label.capitalize()}ServiceStub"
+            except ImportError:
+                try:
+                    proto_module = importlib.import_module(f"{module_path}.coin_pb2")
+                    grpc_module = importlib.import_module(f"{module_path}.coin_pb2_grpc")
+                    service_stub_name = "CoinServiceStub"
+                except ImportError:
+                    self.log(f"❌ Failed to import proto files from {module_path}")
+                    return False
+
+            server_address = f"localhost:{self.grpc_port}"
+            self.log(f"   Connecting to: {server_address}")
+
+            StubClass = getattr(grpc_module, service_stub_name)
+
+            # Test 1: Valid API key
+            self.log("\n   📝 Test 1: Authentication with valid API key")
+            with grpc.insecure_channel(server_address) as channel:
+                stub = StubClass(channel)
+                metadata = [("x-api-key", self.api_key.key)]
+
+                request = proto_module.GetCoinRequest(symbol="BTC")
+                response = stub.GetCoin(request, metadata=metadata)
+
+                self.log(f"   ✅ Request successful: {response.coin.symbol} - {response.coin.name}")
+
+            # Test 2: Django SECRET_KEY
+            self.log("\n   📝 Test 2: Authentication with Django SECRET_KEY")
+            with grpc.insecure_channel(server_address) as channel:
+                stub = StubClass(channel)
+                metadata = [("x-api-key", settings.SECRET_KEY)]
+
+                request = proto_module.GetCoinRequest(symbol="ETH")
+                response = stub.GetCoin(request, metadata=metadata)
+
+                self.log(f"   ✅ SECRET_KEY works: {response.coin.symbol} - {response.coin.name}")
+
+            # Test 3: Invalid key
+            self.log("\n   📝 Test 3: Testing invalid key")
+            try:
+                with grpc.insecure_channel(server_address) as channel:
+                    stub = StubClass(channel)
+                    metadata = [("x-api-key", "invalid_key_12345")]
+
+                    request = proto_module.GetCoinRequest(symbol="BTC")
+                    response = stub.GetCoin(request, metadata=metadata)
+
+                    self.log(f"   ⚠️  Invalid key was accepted (require_auth=False)")
+
+            except grpc.RpcError as e:
+                if e.code() == grpc.StatusCode.UNAUTHENTICATED:
+                    self.log(f"   ✅ Invalid key correctly rejected")
+                else:
+                    self.log(f"   ⚠️  Unexpected error: {e.code()} - {e.details()}")
+
+            self.log("\n✅ All client tests passed")
+            return True
+
+        except grpc.RpcError as e:
+            self.log(f"❌ gRPC error: {e.code()} - {e.details()}")
+            return False
+        except Exception as e:
+            self.log(f"❌ Client testing error: {e}")
+            import traceback
+            if not self.quiet:
+                traceback.print_exc()
+            return False
+
+    def step5_verify_logs(self) -> bool:
+        """Step 5: Verify request logs."""
+        self.print_step(5, "Verifying request logs")
+
+        try:
+            self.api_key.refresh_from_db()
+
+            self.log(f"📊 API key statistics:")
+            self.log(f"   Request count: {self.api_key.request_count}")
+            self.log(f"   Last used: {self.api_key.last_used_at}")
+
+            logs_with_key = GRPCRequestLog.objects.filter(api_key=self.api_key)
+            logs_without_key = GRPCRequestLog.objects.filter(
+                api_key__isnull=True,
+                is_authenticated=True
+            )
+
+            self.log(f"\n📝 Request logs:")
+            self.log(f"   With API key: {logs_with_key.count()}")
+            self.log(f"   With SECRET_KEY: {logs_without_key.count()}")
+            self.log(f"   Total logs: {GRPCRequestLog.objects.count()}")
+
+            if logs_with_key.exists() and not self.quiet:
+                self.log(f"\n   Recent requests with API key:")
+                for log in logs_with_key.order_by("-created_at")[:3]:
+                    self.log(f"   - {log.method_name}: {log.status} ({log.duration_ms}ms)")
+                    self.log(f"     API Key: {log.api_key.name if log.api_key else 'None'}")
+                    self.log(f"     User: {log.user.username if log.user else 'None'}")
+
+            self.log("\n✅ Logs correctly recorded with api_key")
+            return True
+
+        except Exception as e:
+            self.log(f"❌ Log verification error: {e}")
+            import traceback
+            if not self.quiet:
+                traceback.print_exc()
+            return False
+
+    def step6_cleanup(self) -> bool:
+        """Step 6: Clean up test data."""
+        self.print_step(6, "Cleaning up test data")
+
+        try:
+            if self.server_process:
+                self.log("   Stopping gRPC server...")
+                self.server_process.terminate()
+                try:
+                    self.server_process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.server_process.kill()
+                self.log(f"   ✅ Server stopped (PID: {self.server_process.pid})")
+
+            if self.api_key:
+                self.log(f"   Deleting API key: {self.api_key.name}...")
+                self.api_key.delete()
+                self.log("   ✅ API key deleted")
+
+            self.log("\n✅ Cleanup completed")
+            return True
+
+        except Exception as e:
+            self.log(f"❌ Cleanup error: {e}")
+            return False
+
+    def run(self) -> bool:
+        """Run full integration test."""
+        self.log("=" * 70)
+        self.log("🧪 Comprehensive gRPC API Keys Integration Test")
+        self.log("=" * 70)
+
+        results = []
+
+        results.append(("Proto generation", self.step1_generate_protos()))
+
+        if results[-1][1]:
+            results.append(("Server startup", self.step2_start_server()))
+
+        if results[-1][1]:
+            results.append(("API key creation", self.step3_create_api_key()))
+
+        if results[-1][1]:
+            results.append(("Client testing", self.step4_test_client()))
+
+        if results[-1][1]:
+            results.append(("Log verification", self.step5_verify_logs()))
+
+        results.append(("Cleanup", self.step6_cleanup()))
+
+        self.log("\n" + "=" * 70)
+        self.log("📊 Integration Test Results")
+        self.log("=" * 70)
+
+        success_count = sum(1 for _, success in results if success)
+        total_count = len(results)
+
+        for step_name, success in results:
+            status = "✅" if success else "❌"
+            self.log(f"{status} {step_name}")
+
+        self.log("\n" + "=" * 70)
+        if success_count == total_count:
+            self.log(f"🎉 All tests passed successfully! ({success_count}/{total_count})")
+            self.log("=" * 70)
+            return True
+        else:
+            self.log(f"⚠️  Tests passed: {success_count}/{total_count}")
+            self.log("=" * 70)
+            return False
+
+
+__all__ = ["GRPCIntegrationTest"]