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

django_cfg/apps/integrations/grpc/services/testing_service.py

@@ -0,0 +1,326 @@
+"""
+Testing Service.
+
+Provides business logic for gRPC testing operations.
+"""
+
+from typing import Dict, List, Optional
+
+from django.db import models
+from django.db.models import Count
+from django_cfg.modules.django_logging import get_logger
+
+from ..models import GRPCRequestLog
+from ..serializers.testing import (
+    GRPCCallResponseSerializer,
+    GRPCExampleSerializer,
+    GRPCTestLogSerializer,
+)
+from ..testing import get_example
+from .service_registry import ServiceRegistryManager
+
+logger = get_logger("grpc.testing_service")
+
+
+class TestingService:
+    """
+    Service for gRPC testing operations.
+
+    Provides methods to retrieve test examples, logs, and execute test calls.
+    """
+
+    def __init__(self):
+        """Initialize testing service with registry manager."""
+        self.registry = ServiceRegistryManager()
+
+    def get_examples(
+        self,
+        service_filter: Optional[str] = None,
+        method_filter: Optional[str] = None,
+    ) -> List[Dict]:
+        """
+        Get example payloads for testing gRPC methods.
+
+        Args:
+            service_filter: Filter by service name
+            method_filter: Filter by method name
+
+        Returns:
+            List of example dictionaries
+
+        Example:
+            >>> service = TestingService()
+            >>> examples = service.get_examples(service_filter='CryptoService')
+            >>> examples[0]['method']
+            'GetCoin'
+        """
+        # Get registered services from service registry
+        services = self.registry.get_all_services()
+
+        examples = []
+        for service in services:
+            service_name = service.get("class_name", "")
+            if not service_name:
+                continue
+
+            # Filter by service if specified
+            if service_filter and service_name != service_filter:
+                continue
+
+            for method_name in service.get("methods", []):
+                # Filter by method if specified
+                if method_filter and method_name != method_filter:
+                    continue
+
+                # Get example from registry
+                example_data = get_example(service_name, method_name)
+                if example_data:
+                    # Validate and serialize
+                    example = GRPCExampleSerializer(
+                        service=service_name,
+                        method=method_name,
+                        description=example_data.get(
+                            "description", f"{method_name} method"
+                        ),
+                        request_example=example_data.get("request", {}),
+                        response_example=example_data.get("response", {}),
+                        notes=example_data.get("notes", ""),
+                    )
+                    examples.append(example.model_dump())
+
+        return examples
+
+    def get_test_logs(
+        self,
+        service_filter: Optional[str] = None,
+        method_filter: Optional[str] = None,
+        status_filter: Optional[str] = None,
+    ):
+        """
+        Get test logs queryset for gRPC calls.
+
+        Args:
+            service_filter: Filter by service name
+            method_filter: Filter by method name
+            status_filter: Filter by status (success/error)
+
+        Returns:
+            Queryset of GRPCRequestLog (pagination handled by DRF)
+
+        Example:
+            >>> service = TestingService()
+            >>> queryset = service.get_test_logs(status_filter='error')
+            >>> queryset.count()
+            25
+        """
+        # Build queryset with filters
+        queryset = GRPCRequestLog.objects.all()
+
+        if service_filter:
+            queryset = queryset.filter(service_name__icontains=service_filter)
+        if method_filter:
+            queryset = queryset.filter(method_name__icontains=method_filter)
+        if status_filter:
+            queryset = queryset.filter(status=status_filter)
+
+        return queryset.order_by("-created_at")
+
+    def get_test_statistics(self) -> Dict:
+        """
+        Get overall test statistics.
+
+        Returns:
+            Dictionary with test statistics
+
+        Example:
+            >>> service = TestingService()
+            >>> stats = service.get_test_statistics()
+            >>> stats['total_tests']
+            1000
+        """
+        # Get overall stats
+        stats = GRPCRequestLog.objects.aggregate(
+            total_tests=Count("id"),
+            successful=Count("id", filter=models.Q(status="success")),
+            errors=Count("id", filter=models.Q(status="error")),
+        )
+
+        total = stats["total_tests"] or 0
+        successful = stats["successful"] or 0
+        success_rate = (successful / total * 100) if total > 0 else 0.0
+
+        return {
+            "total_tests": total,
+            "successful": successful,
+            "errors": stats["errors"] or 0,
+            "success_rate": round(success_rate, 2),
+        }
+
+    def call_method(
+        self,
+        service_name: str,
+        method_name: str,
+        request_data: Dict,
+        metadata: Optional[Dict] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict:
+        """
+        Call a gRPC method for testing using dynamic invocation.
+
+        Args:
+            service_name: Service name (e.g., 'apps.CryptoService')
+            method_name: Method name (e.g., 'GetCoin')
+            request_data: Request payload as dictionary
+            metadata: Optional metadata (headers)
+            timeout: Timeout in seconds (default: 5.0)
+
+        Returns:
+            Dictionary with call result (to be wrapped by view layer):
+            {
+                'success': bool,
+                'service': str,
+                'method': str,
+                'duration_ms': int,
+                'grpc_status_code': str,
+                'response': dict (if success) or None,
+                'error_message': str (if error) or None,
+            }
+
+        Example:
+            >>> service = TestingService()
+            >>> response = service.call_method(
+            ...     service_name='apps.CryptoService',
+            ...     method_name='GetCoin',
+            ...     request_data={'symbol': 'BTC'},
+            ...     timeout=5.0
+            ... )
+            >>> response['success']
+            True
+            >>> response['response']
+            {'coin': {'symbol': 'BTC', 'price': 50000.0}}
+        """
+        import grpc
+        from time import time
+
+        from .grpc_client import DynamicGRPCClient
+        from .config_helper import get_grpc_server_config
+
+        # Get gRPC server config
+        grpc_config = get_grpc_server_config()
+        host = getattr(grpc_config, "host", "localhost")
+        port = getattr(grpc_config, "port", 50051)
+
+        # Set default timeout
+        if timeout is None:
+            timeout = 5.0
+
+        logger.info(f"Calling gRPC method: {service_name}.{method_name}")
+
+        start_time = time()
+
+        try:
+            # Create dynamic client and make the call
+            with DynamicGRPCClient(host=host, port=port) as client:
+                response_data = client.call_method(
+                    service_name=service_name,
+                    method_name=method_name,
+                    request_data=request_data,
+                    metadata=metadata,
+                    timeout=timeout,
+                )
+
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.info(
+                f"gRPC call successful: {service_name}.{method_name} " f"({duration_ms}ms)"
+            )
+
+            # Return success response (view layer will add request_id, status, timestamp)
+            return {
+                "success": True,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "OK",
+                "response": response_data,
+                "error_message": None,
+            }
+
+        except grpc.RpcError as e:
+            # Handle gRPC errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"gRPC call failed: {service_name}.{method_name} - "
+                f"{e.code()}: {e.details()} ({duration_ms}ms)"
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": e.code().name,
+                "response": None,
+                "error_message": e.details() or f"gRPC error: {e.code()}",
+            }
+
+        except ConnectionError as e:
+            # Handle connection errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"Cannot connect to gRPC server: {host}:{port} - {e} ({duration_ms}ms)"
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "UNAVAILABLE",
+                "response": None,
+                "error_message": f"Cannot connect to gRPC server: {e}",
+            }
+
+        except ValueError as e:
+            # Handle validation errors (service/method not found, invalid request data)
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(f"Validation error: {e} ({duration_ms}ms)")
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "INVALID_ARGUMENT",
+                "response": None,
+                "error_message": str(e),
+            }
+
+        except Exception as e:
+            # Handle unexpected errors
+            end_time = time()
+            duration_ms = int((end_time - start_time) * 1000)
+
+            logger.error(
+                f"Unexpected error calling gRPC method: {e} ({duration_ms}ms)", exc_info=True
+            )
+
+            return {
+                "success": False,
+                "service": service_name,
+                "method": method_name,
+                "duration_ms": duration_ms,
+                "grpc_status_code": "INTERNAL",
+                "response": None,
+                "error_message": f"Internal error: {str(e)}",
+            }
+
+
+__all__ = ["TestingService"]

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

@@ -0,0 +1,12 @@
+"""
+Testing utilities for gRPC services.
+
+Provides example payloads and testing helpers for gRPC methods.
+"""
+
+from .examples import EXAMPLES_REGISTRY, get_example
+
+__all__ = [
+    "EXAMPLES_REGISTRY",
+    "get_example",
+]

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,39 @@
+"""
+URL patterns for gRPC module.
+
+Public API endpoints for gRPC monitoring.
+"""
+
+from django.urls import include, path
+from rest_framework import routers
+
+from .views.charts import GRPCChartsViewSet
+from .views.config import GRPCConfigViewSet
+from .views.monitoring import GRPCMonitorViewSet
+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')
+
+urlpatterns = [
+    # Include router URLs
+    path('', include(router.urls)),
+]

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

@@ -0,0 +1,18 @@
+"""
+gRPC utilities.
+
+Provides proto generation and other helper utilities for gRPC integration.
+
+Note:
+    For dependency checking, use `django_cfg.apps.integrations.grpc._cfg` instead.
+    This module focuses on user-facing utilities like proto generation.
+"""
+
+from .proto_gen import ProtoFieldMapper, ProtoGenerator, generate_proto_for_app
+
+__all__ = [
+    # Proto generation
+    "ProtoFieldMapper",
+    "ProtoGenerator",
+    "generate_proto_for_app",
+]