django-cfg 1.4.4__py3-none-any.whl → 1.4.5__py3-none-any.whl

django_cfg/apps/api/endpoints/serializers.py

@@ -0,0 +1,103 @@
+"""
+Django CFG Endpoints Status Serializers
+
+DRF serializers for endpoints status check API.
+"""
+
+from rest_framework import serializers
+
+
+class EndpointSerializer(serializers.Serializer):
+    """Serializer for single endpoint status."""
+
+    url = serializers.CharField(
+        help_text="URL pattern of the endpoint"
+    )
+    url_name = serializers.CharField(
+        required=False,
+        allow_null=True,
+        help_text="Django URL name (if available)"
+    )
+    namespace = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="URL namespace"
+    )
+    group = serializers.CharField(
+        help_text="URL group (up to 3 depth)"
+    )
+    view = serializers.CharField(
+        required=False,
+        help_text="View function/class name"
+    )
+    status = serializers.CharField(
+        help_text="Status: healthy, unhealthy, warning, error, skipped, pending"
+    )
+    status_code = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        help_text="HTTP status code"
+    )
+    response_time_ms = serializers.FloatField(
+        required=False,
+        allow_null=True,
+        help_text="Response time in milliseconds"
+    )
+    is_healthy = serializers.BooleanField(
+        required=False,
+        allow_null=True,
+        help_text="Whether endpoint is healthy"
+    )
+    error = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Error message if check failed"
+    )
+    reason = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        help_text="Reason for skip (if skipped)"
+    )
+    last_checked = serializers.DateTimeField(
+        required=False,
+        allow_null=True,
+        help_text="Timestamp of last check"
+    )
+    required_auth = serializers.BooleanField(
+        required=False,
+        default=False,
+        help_text="Whether endpoint required JWT authentication"
+    )
+
+
+class EndpointsStatusSerializer(serializers.Serializer):
+    """Serializer for overall endpoints status response."""
+
+    status = serializers.CharField(
+        help_text="Overall status: healthy, degraded, or unhealthy"
+    )
+    timestamp = serializers.DateTimeField(
+        help_text="Timestamp of the check"
+    )
+    total_endpoints = serializers.IntegerField(
+        help_text="Total number of endpoints checked"
+    )
+    healthy = serializers.IntegerField(
+        help_text="Number of healthy endpoints"
+    )
+    unhealthy = serializers.IntegerField(
+        help_text="Number of unhealthy endpoints"
+    )
+    warnings = serializers.IntegerField(
+        help_text="Number of endpoints with warnings"
+    )
+    errors = serializers.IntegerField(
+        help_text="Number of endpoints with errors"
+    )
+    skipped = serializers.IntegerField(
+        help_text="Number of skipped endpoints"
+    )
+    endpoints = EndpointSerializer(
+        many=True,
+        help_text="List of all endpoints with their status"
+    )

django_cfg/apps/api/endpoints/tests.py

@@ -0,0 +1,281 @@
+"""
+Tests for Django CFG Endpoints Status API
+"""
+
+from django.test import TestCase, Client
+from django.urls import reverse, path
+from django.http import JsonResponse
+from django.views import View
+from .checker import (
+    get_url_group,
+    should_check_endpoint,
+    collect_endpoints,
+    check_endpoint,
+    check_all_endpoints,
+)
+
+
+class DummyView(View):
+    """Dummy view for testing."""
+    def get(self, request):
+        return JsonResponse({'status': 'ok'})
+
+
+class GetUrlGroupTests(TestCase):
+    """Test URL grouping logic."""
+
+    def test_simple_url(self):
+        """Test simple URL grouping."""
+        self.assertEqual(get_url_group('/api/accounts/profile/'), 'api/accounts/profile')
+
+    def test_url_with_depth_limit(self):
+        """Test URL grouping respects depth limit."""
+        self.assertEqual(get_url_group('/api/payments/webhook/status/', depth=3), 'api/payments/webhook')
+        self.assertEqual(get_url_group('/api/payments/webhook/status/', depth=2), 'api/payments')
+
+    def test_url_with_parameters(self):
+        """Test URL grouping ignores parameters."""
+        self.assertEqual(get_url_group('/api/users/<int:pk>/orders/'), 'api/users/orders')
+
+    def test_root_url(self):
+        """Test root URL."""
+        self.assertEqual(get_url_group('/'), 'root')
+
+    def test_trailing_slash(self):
+        """Test URLs with/without trailing slash."""
+        self.assertEqual(get_url_group('/api/test'), 'api/test')
+        self.assertEqual(get_url_group('/api/test/'), 'api/test')
+
+
+class ShouldCheckEndpointTests(TestCase):
+    """Test endpoint filtering logic."""
+
+    def test_should_check_api_endpoints(self):
+        """API endpoints should be checked."""
+        self.assertTrue(should_check_endpoint('/api/accounts/profile/'))
+        self.assertTrue(should_check_endpoint('/api/payments/create/'))
+
+    def test_should_exclude_health_endpoints(self):
+        """Health endpoints should be excluded to avoid recursion."""
+        self.assertFalse(should_check_endpoint('/cfg/health/'))
+        self.assertFalse(should_check_endpoint('/cfg/health/drf/'))
+        self.assertFalse(should_check_endpoint('/cfg/health/quick/'))
+
+    def test_should_exclude_endpoints_endpoints(self):
+        """Endpoints status endpoints should be excluded to avoid recursion."""
+        self.assertFalse(should_check_endpoint('/cfg/api/endpoints/'))
+        self.assertFalse(should_check_endpoint('/cfg/api/endpoints/drf/'))
+
+    def test_should_exclude_admin(self):
+        """Admin endpoints should be excluded."""
+        self.assertFalse(should_check_endpoint('/admin/'))
+        self.assertFalse(should_check_endpoint('/admin/auth/user/'))
+
+    def test_should_exclude_static(self):
+        """Static/media endpoints should be excluded."""
+        self.assertFalse(should_check_endpoint('/static/css/style.css'))
+        self.assertFalse(should_check_endpoint('/media/uploads/image.png'))
+
+    def test_should_exclude_by_name(self):
+        """URLs with excluded names should be excluded."""
+        self.assertFalse(should_check_endpoint('/some/url/', 'django_cfg_health'))
+        self.assertFalse(should_check_endpoint('/some/url/', 'endpoints_status'))
+
+
+class CollectEndpointsTests(TestCase):
+    """Test endpoint collection."""
+
+    def test_collect_simple_endpoint(self):
+        """Test collecting a simple endpoint."""
+        urlpatterns = [
+            path('test/', DummyView.as_view(), name='test_view')
+        ]
+
+        endpoints = collect_endpoints(urlpatterns)
+
+        # Should find the test endpoint
+        test_endpoints = [e for e in endpoints if 'test' in e['url']]
+        self.assertGreater(len(test_endpoints), 0)
+
+    def test_skip_unnamed_endpoints(self):
+        """Test skipping unnamed endpoints."""
+        urlpatterns = [
+            path('named/', DummyView.as_view(), name='named_view'),
+            path('unnamed/', DummyView.as_view()),
+        ]
+
+        endpoints = collect_endpoints(urlpatterns, include_unnamed=False)
+
+        # Should only include named endpoint
+        urls = [e['url'] for e in endpoints]
+        self.assertIn('/named/', urls)
+        self.assertNotIn('/unnamed/', urls)
+
+    def test_include_unnamed_endpoints(self):
+        """Test including unnamed endpoints."""
+        urlpatterns = [
+            path('unnamed/', DummyView.as_view()),
+        ]
+
+        endpoints = collect_endpoints(urlpatterns, include_unnamed=True)
+
+        # Should include unnamed endpoint
+        urls = [e['url'] for e in endpoints]
+        self.assertIn('/unnamed/', urls)
+
+    def test_skip_parameterized_urls(self):
+        """Test that URLs with parameters are skipped."""
+        urlpatterns = [
+            path('users/<int:pk>/', DummyView.as_view(), name='user_detail'),
+        ]
+
+        endpoints = collect_endpoints(urlpatterns)
+
+        # Should be marked as skipped
+        param_endpoints = [e for e in endpoints if '<int:pk>' in e['url']]
+        if param_endpoints:
+            self.assertEqual(param_endpoints[0]['status'], 'skipped')
+            self.assertEqual(param_endpoints[0]['reason'], 'requires_parameters')
+
+    def test_url_grouping(self):
+        """Test that URLs are grouped correctly."""
+        urlpatterns = [
+            path('api/accounts/profile/', DummyView.as_view(), name='profile'),
+        ]
+
+        endpoints = collect_endpoints(urlpatterns)
+
+        # Find the profile endpoint
+        profile_endpoints = [e for e in endpoints if 'profile' in e.get('url', '')]
+        if profile_endpoints:
+            self.assertEqual(profile_endpoints[0]['group'], 'api/accounts/profile')
+
+
+class CheckEndpointTests(TestCase):
+    """Test single endpoint checking."""
+
+    def test_check_healthy_endpoint(self):
+        """Test checking a healthy endpoint."""
+        endpoint = {
+            'url': '/',
+            'url_name': 'home',
+            'namespace': '',
+            'group': 'root',
+            'view': 'DummyView',
+            'status': 'pending',
+        }
+
+        client = Client()
+        result = check_endpoint(endpoint, client=client, timeout=5)
+
+        # Check result structure
+        self.assertIn('status_code', result)
+        self.assertIn('response_time_ms', result)
+        self.assertIn('is_healthy', result)
+        self.assertIn('status', result)
+        self.assertIn('last_checked', result)
+
+    def test_skip_skipped_endpoint(self):
+        """Test that skipped endpoints remain skipped."""
+        endpoint = {
+            'url': '/api/users/<int:pk>/',
+            'status': 'skipped',
+            'reason': 'requires_parameters',
+        }
+
+        result = check_endpoint(endpoint)
+
+        # Should remain skipped
+        self.assertEqual(result['status'], 'skipped')
+        self.assertNotIn('status_code', result)
+
+
+class CheckAllEndpointsTests(TestCase):
+    """Test complete endpoint checking."""
+
+    def test_check_all_endpoints_structure(self):
+        """Test that check_all_endpoints returns correct structure."""
+        result = check_all_endpoints(include_unnamed=False, timeout=5)
+
+        # Check top-level structure
+        self.assertIn('status', result)
+        self.assertIn('timestamp', result)
+        self.assertIn('total_endpoints', result)
+        self.assertIn('healthy', result)
+        self.assertIn('unhealthy', result)
+        self.assertIn('warnings', result)
+        self.assertIn('errors', result)
+        self.assertIn('skipped', result)
+        self.assertIn('endpoints', result)
+
+    def test_check_all_endpoints_overall_status(self):
+        """Test that overall status is calculated correctly."""
+        result = check_all_endpoints(include_unnamed=False, timeout=5)
+
+        # Status should be one of the valid options
+        self.assertIn(result['status'], ['healthy', 'degraded', 'unhealthy'])
+
+    def test_statistics_add_up(self):
+        """Test that endpoint statistics add up correctly."""
+        result = check_all_endpoints(include_unnamed=False, timeout=5)
+
+        total = result['total_endpoints']
+        sum_stats = (
+            result['healthy'] +
+            result['unhealthy'] +
+            result['warnings'] +
+            result['errors'] +
+            result['skipped']
+        )
+
+        # Total should equal sum of all categories
+        self.assertEqual(total, sum_stats)
+
+
+class EndpointsAPITests(TestCase):
+    """Test the API endpoints themselves."""
+
+    def test_endpoints_status_view_accessible(self):
+        """Test that the endpoints status view is accessible."""
+        # This will fail if URLs are not properly configured
+        try:
+            url = reverse('endpoints_status')
+            response = self.client.get(url)
+
+            # Should return 200 or 503
+            self.assertIn(response.status_code, [200, 503])
+
+            # Should return JSON
+            self.assertEqual(response['Content-Type'], 'application/json')
+
+        except Exception as e:
+            # If reverse fails, URLs might not be loaded yet
+            self.skipTest(f"URL reverse failed: {e}")
+
+    def test_endpoints_status_drf_view_accessible(self):
+        """Test that the DRF endpoints status view is accessible."""
+        try:
+            url = reverse('endpoints_status_drf')
+            response = self.client.get(url)
+
+            # Should return 200 or 503
+            self.assertIn(response.status_code, [200, 503])
+
+        except Exception as e:
+            self.skipTest(f"URL reverse failed: {e}")
+
+    def test_endpoints_status_query_params(self):
+        """Test query parameters work."""
+        try:
+            url = reverse('endpoints_status')
+
+            # Test with include_unnamed
+            response = self.client.get(url, {'include_unnamed': 'true'})
+            self.assertIn(response.status_code, [200, 503])
+
+            # Test with timeout
+            response = self.client.get(url, {'timeout': '10'})
+            self.assertIn(response.status_code, [200, 503])
+
+        except Exception as e:
+            self.skipTest(f"URL reverse failed: {e}")

django_cfg/apps/api/endpoints/urls.py

@@ -0,0 +1,14 @@
+"""
+Django CFG Endpoints Status URLs.
+"""
+
+from django.urls import path
+from . import views, drf_views
+
+urlpatterns = [
+    # Original JSON endpoint
+    path('', views.EndpointsStatusView.as_view(), name='endpoints_status'),
+
+    # DRF Browsable API endpoint with Tailwind theme
+    path('drf/', drf_views.DRFEndpointsStatusView.as_view(), name='endpoints_status_drf'),
+]

django_cfg/apps/api/endpoints/views.py

@@ -0,0 +1,41 @@
+"""
+Django CFG Endpoints Status Views
+
+Plain Django views for endpoints status checking.
+"""
+
+from django.http import JsonResponse
+from django.views import View
+from .checker import check_all_endpoints
+
+
+class EndpointsStatusView(View):
+    """
+    Django CFG endpoints status check.
+
+    Checks all registered URL endpoints and returns their health status.
+    Excludes health check endpoints to avoid recursion.
+    """
+
+    def get(self, request):
+        """Return endpoints status data."""
+        # Get query parameters
+        include_unnamed = request.GET.get('include_unnamed', 'false').lower() == 'true'
+        timeout = int(request.GET.get('timeout', 5))
+        auto_auth = request.GET.get('auto_auth', 'true').lower() == 'true'
+
+        # Check all endpoints
+        status_data = check_all_endpoints(
+            include_unnamed=include_unnamed,
+            timeout=timeout,
+            auto_auth=auto_auth
+        )
+
+        # Return appropriate HTTP status
+        status_code = 200
+        if status_data["status"] == "unhealthy":
+            status_code = 503
+        elif status_data["status"] == "degraded":
+            status_code = 200  # Still operational
+
+        return JsonResponse(status_data, status=status_code)

django_cfg/apps/payments/admin_interface/views/api/webhook_admin.py

@@ -154,8 +154,8 @@ class AdminWebhookEventViewSet(AdminReadOnlyViewSet):
     
     # No model - using mock data for now
     serializer_class = WebhookEventListSerializer
-    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
-    filterset_fields = ['event_type', 'status', 'provider']
+    filter_backends = [SearchFilter, OrderingFilter]
+    # filterset_fields removed - not compatible with mock data approach
     search_fields = ['event_type', 'webhook_url']
     ordering_fields = ['timestamp', 'event_type', 'status']
     ordering = ['-timestamp']

django_cfg/apps/urls.py

@@ -21,7 +21,9 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
     patterns = [
         # Core APIs (always enabled)
         path('health/', include('django_cfg.apps.api.health.urls')),
+        path('endpoints/', include('django_cfg.apps.api.endpoints.urls')),
         path('commands/', include('django_cfg.apps.api.commands.urls')),
+        
     ]
     
     try:

django_cfg/management/commands/check_endpoints.py

@@ -0,0 +1,146 @@
+"""
+Django management command to check all API endpoints status.
+
+Usage:
+    python manage.py check_endpoints
+    python manage.py check_endpoints --include-unnamed
+    python manage.py check_endpoints --timeout 10
+    python manage.py check_endpoints --json
+"""
+
+from django.core.management.base import BaseCommand
+from django.urls import reverse
+from django_cfg.apps.api.endpoints.checker import check_all_endpoints
+import json
+
+
+class Command(BaseCommand):
+    help = 'Check status of all Django CFG API endpoints'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--include-unnamed',
+            action='store_true',
+            help='Include unnamed URL patterns in the check',
+        )
+        parser.add_argument(
+            '--timeout',
+            type=int,
+            default=5,
+            help='Request timeout in seconds (default: 5)',
+        )
+        parser.add_argument(
+            '--json',
+            action='store_true',
+            help='Output results as JSON',
+        )
+        parser.add_argument(
+            '--url',
+            type=str,
+            help='Check specific endpoint by URL name (e.g., "endpoints_status")',
+        )
+        parser.add_argument(
+            '--no-auth',
+            action='store_true',
+            help='Disable automatic JWT authentication retry (default: enabled)',
+        )
+
+    def handle(self, *args, **options):
+        include_unnamed = options['include_unnamed']
+        timeout = options['timeout']
+        output_json = options['json']
+        url_name = options.get('url')
+        auto_auth = not options['no_auth']  # Auto-auth enabled by default
+
+        # If specific URL requested, just resolve and display it
+        if url_name:
+            try:
+                url = reverse(url_name)
+                self.stdout.write(self.style.SUCCESS(f'✅ URL name "{url_name}" resolves to: {url}'))
+                return
+            except Exception as e:
+                self.stdout.write(self.style.ERROR(f'❌ Error resolving URL "{url_name}": {e}'))
+                return
+
+        # Check all endpoints
+        auth_msg = "with auto-auth" if auto_auth else "without auth"
+        self.stdout.write(self.style.WARNING(f'🔍 Checking endpoints (timeout: {timeout}s, {auth_msg})...'))
+
+        status_data = check_all_endpoints(
+            include_unnamed=include_unnamed,
+            timeout=timeout,
+            auto_auth=auto_auth
+        )
+
+        # Output as JSON if requested
+        if output_json:
+            self.stdout.write(json.dumps(status_data, indent=2))
+            return
+
+        # Pretty print results
+        self._print_results(status_data)
+
+    def _print_results(self, data):
+        """Print formatted results to console."""
+
+        # Overall status
+        status = data['status']
+        if status == 'healthy':
+            status_style = self.style.SUCCESS
+            emoji = '✅'
+        elif status == 'degraded':
+            status_style = self.style.WARNING
+            emoji = '⚠️'
+        else:
+            status_style = self.style.ERROR
+            emoji = '❌'
+
+        self.stdout.write('')
+        self.stdout.write(status_style(f'{emoji} Overall Status: {status.upper()}'))
+        self.stdout.write('')
+
+        # Summary
+        self.stdout.write(self.style.HTTP_INFO('📊 Summary:'))
+        self.stdout.write(f'  Total endpoints: {data["total_endpoints"]}')
+        self.stdout.write(self.style.SUCCESS(f'  ✅ Healthy: {data["healthy"]}'))
+        self.stdout.write(self.style.WARNING(f'  ⚠️  Warnings: {data["warnings"]}'))
+        self.stdout.write(self.style.ERROR(f'  ❌ Unhealthy: {data["unhealthy"]}'))
+        self.stdout.write(self.style.ERROR(f'  ❌ Errors: {data["errors"]}'))
+        self.stdout.write(f'  ⏭️  Skipped: {data["skipped"]}')
+        self.stdout.write('')
+
+        # Endpoints details
+        self.stdout.write(self.style.HTTP_INFO('🔗 Endpoints:'))
+
+        for endpoint in data['endpoints']:
+            name = endpoint.get('name', 'unnamed')
+            url = endpoint['url']
+            status = endpoint['status']
+
+            if status == 'healthy':
+                icon = '✅'
+                style = self.style.SUCCESS
+            elif status == 'degraded':
+                icon = '⚠️'
+                style = self.style.WARNING
+            else:
+                icon = '❌'
+                style = self.style.ERROR
+
+            self.stdout.write(f'  {icon} {name}')
+            self.stdout.write(f'     URL: {url}')
+            self.stdout.write(style(f'     Status: {status}'))
+
+            if endpoint.get('response_time'):
+                self.stdout.write(f'     Response time: {endpoint["response_time"]:.3f}s')
+
+            if endpoint.get('error'):
+                self.stdout.write(self.style.ERROR(f'     Error: {endpoint["error"]}'))
+
+            if endpoint.get('required_auth'):
+                self.stdout.write(f'     🔐 Required JWT authentication')
+
+            self.stdout.write('')
+
+        # Timestamp
+        self.stdout.write(self.style.HTTP_INFO(f'🕐 Checked at: {data["timestamp"]}'))

django_cfg/modules/django_ipc_client/client.py

@@ -228,6 +228,7 @@ class DjangoCfgRPCClient:
             "method": method,
             "params": json.loads(params_json),  # Embedded as dict
             "correlation_id": cid,
+            "reply_to": reply_key,  # Redis List key for response
             "timeout": timeout,
         }