django-webhook-subscriber 0.4.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

django_webhook_subscriber/tests/test_models.py

@@ -1,301 +1,391 @@
+from django.core.exceptions import ValidationError
 from django.test import TestCase
-from django.contrib.contenttypes.models import ContentType
-from django.utils import timezone
-from django.contrib.auth.models import User
 
-from django_webhook_subscriber import models
+from django_webhook_subscriber import managers, models, validators
 
+from .factories import (
+    ContentTypeFactory,
+    WebhookSubscriberFactory,
+    WebhookSubscriptionFactory,
+)
 
-class WebhookModelTests(TestCase):
 
+class WebhookSubscriberModelTests(TestCase):
     def setUp(self):
-        # Get content type for User model for testing
-        self.user_content_type = ContentType.objects.get_for_model(User)
-
-        # Create a basic webhook for testing
-        self.webhook = models.WebhookRegistry.objects.create(
-            name='Test Webhook',
-            content_type=self.user_content_type,
-            endpoint='https://example.com/webhook',
+        self.content_type = ContentTypeFactory()
+        self.subscriber = models.WebhookSubscriber.objects.create(
+            name="Test Subscriber",
+            target_url="https://example.com/webhook",
+            secret="supersecret",
+            content_type=self.content_type,
         )
 
-    def test_webhook_creation(self):
-        self.assertEqual(self.webhook.name, 'Test Webhook')
-        self.assertEqual(self.webhook.content_type, self.user_content_type)
-        self.assertEqual(self.webhook.endpoint, 'https://example.com/webhook')
-        self.assertEqual(self.webhook.event_signals, [])
-        self.assertTrue(self.webhook.is_active)
-        self.assertTrue(self.webhook.secret)
-        self.assertEqual(self.webhook.headers, {})
-
-    def test_webhook_string_representation(self):
+    def test_subscriber_model_is_created_successfully(self):
+        self.subscriber.full_clean()
+        self.assertIsNotNone(self.subscriber.id)
+        self.assertEqual(self.subscriber.name, "Test Subscriber")
         self.assertEqual(
-            str(self.webhook), 'Test Webhook - https://example.com/webhook'
+            self.subscriber.target_url,
+            "https://example.com/webhook",
         )
+        self.assertEqual(self.subscriber.secret, "supersecret")
+        self.assertEqual(self.subscriber.content_type, self.content_type)
+        # Asserting Default Values
+        self.assertTrue(self.subscriber.is_active)
+        self.assertEqual(self.subscriber.description, "")
+        self.assertEqual(self.subscriber.headers, {})
+        self.assertIsNone(self.subscriber.last_success)
+        self.assertIsNone(self.subscriber.last_failure)
+        self.assertEqual(self.subscriber.max_retries, 3)
+        self.assertEqual(self.subscriber.retry_delay, 60)
+        # Asserting Meta Fields
+        self.assertIsNotNone(self.subscriber.created_at)
+        self.assertIsNotNone(self.subscriber.updated_at)
+
+    def test_subscriber_model_unique_together_constraint(self):
+        with self.assertRaises(Exception) as context:
+            models.WebhookSubscriber.objects.create(
+                name="Duplicate Subscriber",
+                content_type=self.content_type,
+                target_url="https://example.com/webhook",
+                secret="anothersecret",
+            )
+        self.assertIn("already exists", str(context.exception).lower())
 
-    def test_webhook_with_headers(self):
-        custom_headers = {'Authorization': 'Bearer token123'}
-        webhook = models.WebhookRegistry.objects.create(
-            name='Webhook with Headers',
-            content_type=self.user_content_type,
-            event_signals=['DELETE'],
-            endpoint='https://example.com/webhook2',
-            headers=custom_headers,
+    def test_subscriber_model_str_representation(self):
+        self.assertEqual(
+            str(self.subscriber),
+            "Test Subscriber (https://example.com/webhook)",
         )
-        self.assertEqual(webhook.headers, custom_headers)
-
-    def test_event_signals_jsonfield(self):
-        # Test with a single event type
-        webhook = models.WebhookRegistry.objects.create(
-            name='Single Event Webhook',
-            content_type=self.user_content_type,
-            event_signals=['CREATE'],
-            endpoint='https://example.com/create-only',
+
+    def test_subscriber_model_clean_method_validates_timeout(self):
+        invalid_subscriber = models.WebhookSubscriber(
+            name="Invalid Timeout Subscriber",
+            target_url="https://example.com/webhook",
+            secret="secret",
+            content_type=self.content_type,
+            timeout=301,  # Invalid timeout (> 300)
         )
-        self.assertEqual(webhook.event_signals, ['CREATE'])
-
-        # Test with multiple event types
-        webhook = models.WebhookRegistry.objects.create(
-            name='All Events Webhook',
-            content_type=self.user_content_type,
-            event_signals=['CREATE', 'UPDATE', 'DELETE'],
-            endpoint='https://example.com/all-events',
+        with self.assertRaises(Exception) as context:
+            invalid_subscriber.full_clean()
+        self.assertIn(
+            "timeout cannot exceed 300 seconds", str(context.exception).lower()
         )
-        self.assertEqual(webhook.event_signals, ['CREATE', 'UPDATE', 'DELETE'])
 
-        # Test with empty list (should use default)
-        webhook = models.WebhookRegistry.objects.create(
-            name='Empty Events Webhook',
-            content_type=self.user_content_type,
-            endpoint='https://example.com/no-events',
+    def test_subscriber_model_clean_method_validates_retry_delay(self):
+        invalid_subscriber = models.WebhookSubscriber(
+            name="Invalid Timeout Subscriber",
+            target_url="https://example.com/webhook",
+            secret="secret",
+            content_type=self.content_type,
+            retry_delay=3601,  # Invalid timeout (> 1 hour)
         )
-        self.assertEqual(webhook.event_signals, [])
-
-    def test_updating_webhook(self):
-        # Update several fields
-        self.webhook.name = 'Updated Webhook'
-        self.webhook.endpoint = 'https://updated-example.com/webhook'
-        self.webhook.event_signals = ['CREATE', 'UPDATE']
-        self.webhook.is_active = False
-        self.webhook.save()
-
-        # Retrieve the webhook from the database again to verify updates
-        updated_webhook = models.WebhookRegistry.objects.get(
-            pk=self.webhook.pk
+        with self.assertRaises(Exception) as context:
+            invalid_subscriber.full_clean()
+        self.assertIn(
+            "retry_delay cannot exceed 3600 seconds",
+            str(context.exception).lower(),
         )
 
-        self.assertEqual(updated_webhook.name, 'Updated Webhook')
+    def test_subscriber_model_model_class_property(self):
         self.assertEqual(
-            updated_webhook.endpoint,
-            'https://updated-example.com/webhook',
+            self.subscriber.model_class,
+            self.content_type.model_class(),
         )
+
+    def test_subscriber_model_model_name_property(self):
         self.assertEqual(
-            updated_webhook.event_signals,
-            ['CREATE', 'UPDATE'],
-        )
-        self.assertFalse(updated_webhook.is_active)
-
-    def test_tracking_fields(self):
-        # Initially, tracking fields should be None
-        self.assertTrue(self.webhook.keep_last_response)
-        self.assertIsNone(self.webhook.last_response)
-        self.assertIsNone(self.webhook.last_success)
-        self.assertIsNone(self.webhook.last_failure)
-
-        # Update tracking fields
-        now = timezone.now()
-        self.webhook.last_response = 'Success: 200 OK'
-        self.webhook.last_success = now
-        self.webhook.save()
-
-        # Retrieve the webhook and verify updates
-        updated_webhook = models.WebhookRegistry.objects.get(
-            pk=self.webhook.pk
+            self.subscriber.model_name,
+            f"{self.content_type.app_label}.{self.content_type.model}",
         )
-        self.assertEqual(updated_webhook.last_response, 'Success: 200 OK')
-        self.assertEqual(updated_webhook.last_success.date(), now.date())
-        self.assertIsNone(updated_webhook.last_failure)
-
-        # Update failure tracking
-        self.webhook.last_response = 'Error: 500 Internal Server Error'
-        self.webhook.last_failure = now
-        self.webhook.save()
-
-        # Retrieve and verify again
-        updated_webhook = models.WebhookRegistry.objects.get(
-            pk=self.webhook.pk
+
+    def test_subscriber_model_record_success_method(self):
+        self.subscriber.record_success()
+        self.subscriber.refresh_from_db()
+        self.assertIsNotNone(self.subscriber.last_success)
+        self.assertIsNone(self.subscriber.last_failure)
+
+    def test_subscriber_model_record_failure_method(self):
+        self.subscriber.record_failure()
+        self.subscriber.refresh_from_db()
+        self.assertIsNotNone(self.subscriber.last_failure)
+        self.assertIsNone(self.subscriber.last_success)
+        # Test consecutive failures increment
+        self.subscriber.record_failure()
+        self.subscriber.refresh_from_db()
+        self.assertEqual(self.subscriber.consecutive_failures, 2)
+        self.subscriber.auto_disable_after_failures = 3
+        self.subscriber.record_failure()
+        self.subscriber.refresh_from_db()
+        self.assertFalse(self.subscriber.is_active)
+        self.assertEqual(self.subscriber.consecutive_failures, 3)
+
+
+class WebhookSubscriptionModelTests(TestCase):
+    def setUp(self):
+        self.subscriber = WebhookSubscriberFactory(name="Test Subscriber")
+        self.subscription = models.WebhookSubscription.objects.create(
+            subscriber=self.subscriber,
+            event_name="created",
         )
+
+    def test_subscription_model_is_created_successfully(self):
+        self.subscription.full_clean()
+        self.assertIsNotNone(self.subscription.id)
+        self.assertEqual(self.subscription.subscriber, self.subscriber)
+        self.assertEqual(self.subscription.event_name, "created")
+        # Asserting Default Values
+        self.assertEqual(self.subscription.custom_endpoint, "")
+        self.assertTrue(self.subscription.is_active)
+        # Asserting Meta Fields
+        self.assertIsNotNone(self.subscription.created_at)
+        self.assertIsNotNone(self.subscription.updated_at)
+
+    def test_subscription_model_str_representation(self):
         self.assertEqual(
-            updated_webhook.last_response,
-            'Error: 500 Internal Server Error',
+            str(self.subscription),
+            "Test Subscriber - created",
         )
-        self.assertEqual(updated_webhook.last_failure.date(), now.date())
-
-    def test_async_delivery_settings(self):
-        # Default values
-        self.assertEqual(self.webhook.max_retries, 3)
-        self.assertEqual(self.webhook.retry_delay, 60)
-        self.assertIsNone(self.webhook.use_async)
-
-        # Update async settings
-        self.webhook.max_retries = 5
-        self.webhook.retry_delay = 120
-        self.webhook.use_async = True
-        self.webhook.save()
-
-        # Retrieve and verify
-        updated_webhook = models.WebhookRegistry.objects.get(
-            pk=self.webhook.pk
-        )
-        self.assertEqual(updated_webhook.max_retries, 5)
-        self.assertEqual(updated_webhook.retry_delay, 120)
-        self.assertTrue(updated_webhook.use_async)
 
+    def test_subscription_model_unique_together_constraint(self):
+        with self.assertRaises(Exception) as context:
+            models.WebhookSubscription.objects.create(
+                subscriber=self.subscriber,
+                event_name="created",
+            )
+        self.assertIn("unique constraint", str(context.exception).lower())
+
+    def test_subscription_model_clean_method_validates_event_type(self):
+        pass
 
-class WebhookDeliveryLogModelTests(TestCase):
-    def setUp(self):
-        # Get content type for User model for testing
-        self.user_content_type = ContentType.objects.get_for_model(User)
-
-        # Create a webhook for testing
-        self.webhook = models.WebhookRegistry.objects.create(
-            name='Test Webhook',
-            content_type=self.user_content_type,
-            event_signals=['CREATE', 'UPDATE'],
-            endpoint='https://example.com/webhook',
+    def test_subscription_model_endpoint_property(self):
+        self.subscriber.target_url = "https://example.com/webhook/"
+        self.subscriber.save()
+        self.subscription.custom_endpoint = "/events/create"
+        self.subscription.full_clean()
+        self.assertEqual(
+            self.subscription.endpoint,
+            "https://example.com/webhook/events/create",
         )
 
-        # Create a successful log entry
-        self.success_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='created',
-            payload={'id': 1, 'username': 'testuser', 'event': 'created'},
-            response_status=200,
-            response_body='OK',
+        # Remove endpoint
+        self.subscription.custom_endpoint = ""
+        self.subscription.save()
+        self.assertEqual(
+            self.subscription.endpoint,
+            "https://example.com/webhook/",
         )
 
-        # Create a failed log entry
-        self.failed_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='updated',
-            payload={'id': 1, 'username': 'testuser', 'event': 'updated'},
-            response_status=500,
-            response_body='Internal Server Error',
-            error_message='Server returned 500 status code',
+        # Full endpoint
+        self.subscription.custom_endpoint = "https://another.com/hook"
+        self.subscription.full_clean()
+        self.assertEqual(
+            self.subscription.endpoint,
+            "https://another.com/hook",
         )
 
-    def test_log_creation(self):
-        # Verify the successful log entry
-        self.assertEqual(self.success_log.webhook, self.webhook)
-        self.assertEqual(self.success_log.event_signal, 'created')
-        self.assertEqual(self.success_log.payload['username'], 'testuser')
-        self.assertEqual(self.success_log.response_status, 200)
-        self.assertEqual(self.success_log.response_body, 'OK')
-        self.assertIsNone(self.success_log.error_message)
-
-        # Verify the failed log entry
-        self.assertEqual(self.failed_log.webhook, self.webhook)
-        self.assertEqual(self.failed_log.event_signal, 'updated')
-        self.assertEqual(self.failed_log.payload['username'], 'testuser')
-        self.assertEqual(self.failed_log.response_status, 500)
+    def test_subscription_model_model_name_property(self):
         self.assertEqual(
-            self.failed_log.response_body,
-            'Internal Server Error',
+            self.subscription.model_name,
+            self.subscriber.model_name,
         )
+
+    def test_subscription_model_content_type_property(self):
         self.assertEqual(
-            self.failed_log.error_message,
-            'Server returned 500 status code',
+            self.subscription.content_type,
+            self.subscriber.content_type,
         )
 
-    def test_string_representation(self):
-        # For successful delivery
-        expected_success_str = (
-            f'{self.webhook} - {self.success_log.event_signal} - 200'
+    def test_subscription_model_serializer_class_property(self):
+        self.assertEqual(
+            self.subscription.serializer_class,
+            self.subscriber.serializer_class,
         )
-        self.assertEqual(str(self.success_log), expected_success_str)
 
-        # For failed delivery
-        expected_failed_str = (
-            f'{self.webhook} - {self.failed_log.event_signal} - 500'
-        )
-        self.assertEqual(str(self.failed_log), expected_failed_str)
-
-        # For log with no status (completely failed)
-        no_status_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='deleted',
-            payload={'id': 1, 'username': 'testuser', 'event': 'deleted'},
-            error_message='Connection refused',
-        )
-        expected_no_status_str = (
-            f'{self.webhook} - {no_status_log.event_signal} - Failed'
+    def test_subscription_model_success_rate_property(self):
+        self.assertIsNone(self.subscription.success_rate)
+        self.subscription.total_deliveries = 10
+        self.subscription.successful_deliveries = 7
+        self.subscription.save()
+        self.assertEqual(self.subscription.success_rate, 70.0)
+        self.subscription.successful_deliveries = 10
+        self.subscription.save()
+        self.assertEqual(self.subscription.success_rate, 100.0)
+
+    def test_subscription_model_record_delivery_attempt_method(self):
+        self.subscription.record_delivery_attempt(success=True)
+        self.subscription.refresh_from_db()
+        self.assertEqual(self.subscription.total_deliveries, 1)
+        self.assertEqual(self.subscription.successful_deliveries, 1)
+        self.assertEqual(self.subscription.consecutive_failures, 0)
+
+        self.subscription.record_delivery_attempt(
+            success=False, response_text=str("s") * 1025
         )
-        self.assertEqual(str(no_status_log), expected_no_status_str)
-
-    def test_json_payload_handling(self):
-        # Test with an empty payload
-        empty_payload_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='updated',
-            payload={},
-            response_status=200,
+        self.subscription.refresh_from_db()
+        self.assertEqual(self.subscription.total_deliveries, 2)
+        self.assertEqual(self.subscription.successful_deliveries, 1)
+        self.assertEqual(self.subscription.consecutive_failures, 1)
+        self.assertEqual(len(self.subscription.last_response), 1024)
+
+
+class WebhookDeliveryLogsModelTests(TestCase):
+    def setUp(self):
+        self.subscription = WebhookSubscriptionFactory(event_name="created")
+        self.log = models.WebhookDeliveryLog.objects.create(
+            subscription=self.subscription,
+            payload={"key": "value"},
+            delivery_url=self.subscription.endpoint,
         )
-        self.assertEqual(empty_payload_log.payload, {})
-
-        # Test with a nested payload
-        nested_payload_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='created',
-            payload={
-                'user': {
-                    'id': 5,
-                    'username': 'nesteduser',
-                    'profile': {'age': 30, 'interests': ['python', 'django']},
-                },
-                'timestamp': '2023-01-01T12:00:00Z',
-            },
-            response_status=200,
+
+    def test_delivery_log_model_is_created_successfully(self):
+        self.log.full_clean()
+        self.assertIsNotNone(self.log.id)
+        self.assertEqual(self.log.subscription, self.subscription)
+        self.assertEqual(self.log.payload, {"key": "value"})
+        self.assertIsNotNone(self.log.delivery_url, self.subscription.endpoint)
+        # Asserting Default Values
+        self.assertIsNone(self.log.response_status)
+        self.assertEqual(self.log.response_body, "")
+        self.assertEqual(self.log.response_headers, {})
+        self.assertEqual(self.log.error_message, "")
+        # Asserting Meta Fields
+        self.assertIsNotNone(self.log.created_at)
+
+    def test_delivery_log_model_str_representation(self):
+        self.assertEqual(str(self.log), f"{self.subscription}")
+        self.log.response_status = 200
+        self.assertEqual(str(self.log), f"{self.subscription} (200)")
+        self.log.is_retry = True
+        self.log.attempt_number = 2
+        self.assertEqual(str(self.log), f"{self.subscription} (200) (retry 2)")
+
+    def test_delivery_log_model_uses_custom_manager(self):
+        self.assertIsInstance(
+            models.WebhookDeliveryLog.objects,
+            managers.WebhookDeliveryLogManager,
         )
 
-        # Verify nested data is preserved
-        payload = nested_payload_log.payload
-        self.assertEqual(payload['user']['username'], 'nesteduser')
-        self.assertEqual(payload['user']['profile']['age'], 30)
-        self.assertEqual(payload['user']['profile']['interests'][0], 'python')
-
-        # Test with array in payload
-        array_payload_log = models.WebhookDeliveryLog.objects.create(
-            webhook=self.webhook,
-            event_signal='created',
-            payload=[
-                {'id': 1, 'name': 'Item 1'},
-                {'id': 2, 'name': 'Item 2'},
-                {'id': 3, 'name': 'Item 3'},
-            ],
-            response_status=200,
+    def test_delivery_log_model_event_name_property(self):
+        self.assertEqual(self.log.event_name, "created")
+
+    def test_delivery_log_model_is_success_property(self):
+        self.assertFalse(self.log.is_success)
+        self.log.response_status = 200
+        self.assertTrue(self.log.is_success)
+        self.log.response_status = 404
+        self.assertFalse(self.log.is_success)
+        self.log.error_message = "Timeout"
+        self.log.response_status = 200
+        self.assertFalse(self.log.is_success)  # Exceptions are not successes
+
+    def test_delivery_log_model_is_client_error_property(self):
+        self.assertFalse(self.log.is_client_error)
+        self.log.response_status = 404
+        self.assertTrue(self.log.is_client_error)
+        self.log.response_status = 500
+        self.assertFalse(self.log.is_client_error)
+        self.log.error_message = "Timeout"
+        self.assertFalse(
+            self.log.is_client_error
+        )  # Exceptions are not client errors
+
+    def test_delivery_log_model_is_server_error_property(self):
+        self.assertFalse(self.log.is_server_error)
+        self.log.response_status = 500
+        self.assertTrue(self.log.is_server_error)
+        self.log.response_status = 404
+        self.assertFalse(self.log.is_server_error)
+        self.log.error_message = "Timeout"
+        self.assertFalse(
+            self.log.is_server_error
+        )  # Exceptions are not server errors
+
+
+class ValidateClassPathValidatorTests(TestCase):
+    def test_validate_class_path_on_valid_path(self):
+        try:
+            validators.validate_class_path(
+                "rest_framework.serializers.ModelSerializer"
+            )
+        except ValidationError:
+            self.fail(
+                "validate_class_path raised ValidationError unexpectedly!"
+            )
+
+    def test_validate_class_path_on_empty_value(self):
+        try:
+            validators.validate_class_path("")
+        except ValidationError:
+            self.fail(
+                "validate_class_path raised ValidationError unexpectedly!"
+            )
+
+    def test_validate_class_path_on_invalid_path(self):
+        with self.assertRaises(ValidationError) as context:
+            validators.validate_class_path("non.existent.ClassName")
+
+        self.assertIn("Cannot import class from path", str(context.exception))
+
+    def test_validate_class_path_on_non_serializer_class(self):
+        with self.assertRaises(ValueError) as context:
+            validators.validate_class_path(
+                "django.core.validators.URLValidator"
+            )
+
+        self.assertIn(
+            "field_serializer must be a subclass of",
+            str(context.exception),
         )
 
-        # Verify array is preserved
-        payload = array_payload_log.payload
-        self.assertEqual(len(payload), 3)
-        self.assertEqual(payload[0]['name'], 'Item 1')
-        self.assertEqual(payload[2]['id'], 3)
-
-    def test_multiple_logs_for_webhook(self):
-        # Create several more logs for the same webhook
-        for i in range(5):
-            models.WebhookDeliveryLog.objects.create(
-                webhook=self.webhook,
-                event_signal='created',
-                payload={'id': i + 10, 'name': f'User {i}'},
-                response_status=200,
+
+class ValidateHeadersValidatorTests(TestCase):
+    def test_validate_headers_on_valid_dict(self):
+        try:
+            validators.validate_headers(
+                {
+                    "Content-Type": "application/json",
+                    "X-Custom-Header": "Value",
+                    "X-Empty-Header": None,
+                }
             )
+        except ValidationError:
+            self.fail("validate_headers raised ValidationError unexpectedly!")
+
+    def test_validate_headers_on_empty_dict(self):
+        try:
+            validators.validate_headers({})
+        except ValidationError:
+            self.fail("validate_headers raised ValidationError unexpectedly!")
+
+    def test_validate_headers_on_non_dict(self):
+        with self.assertRaises(ValidationError) as context:
+            validators.validate_headers(["Not", "a", "dict"])
+
+        self.assertIn("Headers must be a dictionary", str(context.exception))
+
+    def test_validate_headers_on_non_string_key(self):
+        with self.assertRaises(ValidationError) as context:
+            validators.validate_headers({123: "value"})
 
-        # Verify through the related_name
-        webhook_logs = self.webhook.delivery_logs.all()
+        self.assertIn(
+            "Header key '123' must be a string", str(context.exception)
+        )
+
+    def test_validate_headers_on_non_string_value(self):
+        with self.assertRaises(ValidationError) as context:
+            validators.validate_headers({"X-Header": 456})
 
-        # Should have 7 logs total (2 from setUp + 5 new ones)
-        self.assertEqual(webhook_logs.count(), 7)
+        self.assertIn(
+            "Header value for 'X-Header' must be a string or None",
+            str(context.exception),
+        )
 
-        # Verify newest log is first in the queryset
-        self.assertEqual(webhook_logs.first().payload['id'], 14)
+    def test_validate_headers_on_invalid_header_name_format(self):
+        with self.assertRaises(ValidationError) as context:
+            validators.validate_headers({"Invalid Header!": "value"})
+
+        self.assertIn(
+            "Invalid header name format: 'Invalid Header!'",
+            str(context.exception),
+        )