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

django_webhook_subscriber/tests/test_utils.py

@@ -1,108 +1,112 @@
-from unittest.mock import patch
-
 from django.test import TestCase, override_settings
-from django.contrib.auth.models import User
-from django.contrib.contenttypes.models import ContentType
-
-from django_webhook_subscriber.models import WebhookRegistry
-from django_webhook_subscriber.signals import register_webhook_signals
-from django_webhook_subscriber.utils import (
-    register_model_config,
-    get_webhook_config,
-    unregister_webhook_signals,
-)
-
-
-class WebhookRegistrationTests(TestCase):
-    def test_register_model_config(self):
-
-        # Register the User model with a serializer and events
-        config = register_model_config(
-            User,
-            serializer='UserSerializer',
-            events=['CREATE', 'UPDATE'],
-        )
 
-        # Check if the configuration is stored correctly
-        self.assertEqual(config['serializer'], 'UserSerializer')
-        self.assertEqual(config['events'], ['CREATE', 'UPDATE'])
+from django_webhook_subscriber import utils
 
-    def test_register_model_config_default(self):
+from .factories import ContentTypeFactory, WebhookSubscriberFactory
 
-        # Register the User model with a serializer and events
-        config = register_model_config(User)
 
-        # Check if the configuration is stored correctly
-        self.assertIsNone(config['serializer'])
-        self.assertEqual(config['events'], ['CREATE', 'UPDATE', 'DELETE'])
+class GenerateHeadersFunctionTests(TestCase):
+    def setUp(self):
+        self.subscriber = WebhookSubscriberFactory()
 
-    def test_get_webhook_config(self):
-        # Register the User model with a serializer and events
-        register_model_config(User, events=['CREATE', 'UPDATE'])
+    def test_generate_headers_on_no_default_headers(self):
+        headers = utils.generate_headers(self.subscriber)
+        # Asserting both X-Secret and Content-Type headers are present
+        self.assertIn("X-Secret", headers)
+        self.assertIn("Content-Type", headers)
+        self.assertEqual(headers["X-Secret"], self.subscriber.secret)
+        self.assertEqual(headers["Content-Type"], "application/json")
 
-        # Retrieve the configuration for the User model
-        config = get_webhook_config(User)
-        self.assertIsNotNone(config)
-        config = get_webhook_config('other_model')
-        self.assertIsNone(config)
+    def test_generate_headers_on_custom_default_headers(self):
+        self.subscriber.headers = {
+            "Custom-Header": "Value",
+            "Content-Type": "application/xml",
+        }
+        headers = utils.generate_headers(self.subscriber)
+        # Asserting both X-Secret and Content-Type headers are present
+        self.assertIn("X-Secret", headers)
+        self.assertIn("Content-Type", headers)
+        self.assertIn("Custom-Header", headers)
+        self.assertEqual(headers["X-Secret"], self.subscriber.secret)
+        self.assertEqual(headers["Content-Type"], "application/xml")
+        self.assertEqual(headers["Custom-Header"], "Value")
 
-    @override_settings(WEBHOOK_SUBSCRIBER_MODELS={'auth.User': {}})
-    @patch('django_webhook_subscriber.signals.process_webhook_event')
-    def test_unregister_webhook_signals(self, mock_delivery):
-        register_webhook_signals(WebhookRegistry)
-        register_webhook_signals(User)
 
-        # Disable all webhooks
-        unregister_webhook_signals()
+class GenerateSecretFunctionTests(TestCase):
+    def test_generate_secret_returns_uuid_string(self):
+        secret = utils.generate_secret()
+        self.assertIsInstance(secret, str)
+        self.assertEqual(len(secret), 36)  # UUID string length
 
-        # creating a user
-        user = User.objects.create(username='testuser')
-        mock_delivery.assert_not_called()
 
-        # updating the user
-        user.save()
-        mock_delivery.assert_not_called()
+class WebhookDisableContextTests(TestCase):
+    def test_webhook_disable_context_manager(self):
+        # By default, webhooks should be enabled
+        self.assertFalse(utils.webhooks_disabled())
 
-        # deleting the user
-        user.delete()
-        mock_delivery.assert_not_called()
+        # Context manager should disable webhooks
+        with utils.disable_webhooks():
+            self.assertTrue(utils.webhooks_disabled())
 
-        # creating a webhook delivery log
-        WebhookRegistry.objects.create(
-            name='Test Webhook',
-            content_type=ContentType.objects.get_for_model(User),
-            event_signals=['CREATE', 'UPDATE'],
-            endpoint='http://example.com/webhook/',
-        )
-        mock_delivery.assert_not_called()
-
-    @override_settings(WEBHOOK_SUBSCRIBER_MODELS={'auth.User': {}})
-    @patch('django_webhook_subscriber.signals.process_webhook_event')
-    def test_unregister_webhook_signals_specific_model(self, mock_delivery):
-        register_webhook_signals(User)
-        register_webhook_signals(WebhookRegistry)
-
-        # Disable all webhooks
-        unregister_webhook_signals(model_class=User)
-
-        # creating a user
-        user = User.objects.create(username='testuser')
-        mock_delivery.assert_not_called()
-
-        # updating the user
-        user.save()
-        mock_delivery.assert_not_called()
-
-        # deleting the user
-        user.delete()
-        mock_delivery.assert_not_called()
-
-        # creating a webhook delivery log
-        WebhookRegistry.objects.create(
-            name='Test Webhook',
-            content_type=ContentType.objects.get_for_model(User),
-            event_signals=['CREATE', 'UPDATE'],
-            endpoint='http://example.com/webhook/',
+            # Nested context managers should also work
+            with utils.disable_webhooks():
+                self.assertTrue(utils.webhooks_disabled())
+
+            self.assertTrue(utils.webhooks_disabled())
+
+        # After context manager, webhooks should be enabled again
+        self.assertFalse(utils.webhooks_disabled())
+
+    @override_settings(DISABLE_WEBHOOKS=True)
+    def test_webhook_disable_context_manager_when_disabled_in_settings(self):
+        # Webhooks should be disabled due to settings
+        self.assertTrue(utils.webhooks_disabled())
+
+        with utils.disable_webhooks():
+            # Even inside the context manager, webhooks remain disabled
+            self.assertTrue(utils.webhooks_disabled())
+
+        self.assertTrue(utils.webhooks_disabled())
+
+
+class ContentTypeCacheTests(TestCase):
+    def setUp(self):
+        self.content_type = ContentTypeFactory(
+            app_label="test_app",
+            model="testmodel",
         )
-        # Verify that the webhook delivery log signal is still connected
-        mock_delivery.assert_called()
+        # Clear cache to ensure fresh state
+        utils.get_content_type_id.cache_clear()
+
+    def test_get_content_type_id_caching(self):
+        # First call should hit the database
+        with self.assertNumQueries(1):
+            ct_id_1 = utils.get_content_type_id("test_app", "testmodel")
+            self.assertIsNotNone(ct_id_1)
+
+        with self.assertNumQueries(0):
+            # Second call should use the cache
+            ct_id_2 = utils.get_content_type_id("test_app", "testmodel")
+            self.assertEqual(ct_id_1, ct_id_2)
+
+    def test_get_content_type_id_non_existent(self):
+        with self.assertNumQueries(1):
+            ct_id = utils.get_content_type_id(
+                "nonexistent_app",
+                "nonexistentmodel",
+            )
+            self.assertIsNone(ct_id)
+
+    def test_clear_content_type_cache(self):
+        with self.assertNumQueries(1):
+            # First call should hit the database
+            ct_id_1 = utils.get_content_type_id("test_app", "testmodel")
+            self.assertIsNotNone(ct_id_1)
+
+        # Clear the cache
+        utils.clear_content_type_cache()
+
+        # Next call should hit the database again (not cached)
+        with self.assertNumQueries(1):
+            ct_id_2 = utils.get_content_type_id("test_app", "testmodel")
+            self.assertEqual(ct_id_1, ct_id_2)

django_webhook_subscriber/utils.py

@@ -1,84 +1,102 @@
-"""Utility functions for Django Webhook Subscriber."""
+"""Utility functions for Django Webhook Subscriber"""
 
-# Dictionary to store model -> configuration mappings
-_webhook_registry = {}
+import contextvars
+import uuid
+from contextlib import contextmanager
+from functools import lru_cache
 
+from django.conf import settings
 
-def get_webhook_config(model_class):
-    """Retrieve the webhook configuration for a model class.
+# =============================================================================
+# Header and secret generation
+# =============================================================================
 
-    If no configuration is found, return None.
-    """
-    return _webhook_registry.get(model_class, None)
 
+def generate_headers(subscriber):
+    """Generate headers for webhook delivery, including custom headers."""
 
-def register_model_config(model_class, serializer=None, events=None):
-    """Register a model class with its configuration.
+    headers = subscriber.headers.copy() if subscriber.headers else {}
 
-    Stores the model class and its configuration in the global
-    registry - _webhook_registry.
-    """
+    # Add content type header if not present
+    if "Content-Type" not in headers:
+        headers["Content-Type"] = "application/json"
+
+    # Add secret key authentication header
+    headers["X-Secret"] = subscriber.secret
+
+    return headers
+
+
+def generate_secret():
+    """Generate a new secret key for webhook authentication."""
+
+    return str(uuid.uuid4())
+
+
+# =============================================================================
+# Webhook enabling/disabling context manager
+# =============================================================================
+
+# We're using contextvars instead of thread locals because:
+# - contextvars provide proper isolation in async environments (async tasks)
+# - they automatically propagate through async/await boundaries
+# - they work correctly with concurrent execution (asyncio, threading)
+# - they ensure webhook state is isolated per request/task context
+
+_webhooks_disabled = contextvars.ContextVar("webhooks_disabled", default=False)
 
-    # If signal_events is None, set it to all events
-    if events is None:
-        events = list(['CREATE', 'UPDATE', 'DELETE'])
-    else:
-        # Normalize signal events to uppercase
-        events = [event.upper() for event in events]
 
-    # Store the configuration in the registry
-    _webhook_registry[model_class] = {
-        'serializer': serializer,
-        'events': events,
-    }
+def webhooks_disabled():
+    """Check if webhooks are currently disabled in this context."""
 
-    return _webhook_registry[model_class]
+    # Check context variable first
+    check_disabled = _webhooks_disabled.get()
 
+    # Check Django settings
+    settings_disabled = getattr(settings, "DISABLE_WEBHOOKS", False)
 
-def unregister_webhook_signals(model_class=None):
-    """Disable webhooks by disconnecting all signals.
+    # Webhooks are disabled if either context or settings says so
+    return check_disabled or settings_disabled
 
-    If a specific model class is provided as an argument, only that model's
-    signals will be disconnected. If no model class is provided, all signals
-    will be disconnected.
-    This function is useful for disabling webhooks in tests or when
-    reconfiguring the webhook system.
+
+@contextmanager
+def disable_webhooks():
+    """Context manager to temporarily disable webhooks.
+
+    Usage:
+        with disable_webhooks():
+            # Code that should not trigger webhooks
+            ...
     """
 
-    from django_webhook_subscriber.signals import (
-        webhook_post_save,
-        webhook_post_delete,
-    )
-    from django.db.models.signals import post_save, post_delete
-
-    if model_class:
-        # If a specific model class is provided, remove its entry from the
-        # registry
-        if model_class in _webhook_registry:
-            post_save.disconnect(
-                webhook_post_save,
-                sender=model_class,
-                dispatch_uid=f'webhook_post_save_{model_class.__name__}',
-            )
-            post_delete.disconnect(
-                webhook_post_delete,
-                sender=model_class,
-                dispatch_uid=f'webhook_post_delete_{model_class.__name__}',
-            )
-        return _webhook_registry
-
-    # Disconnect all signals
-    for model_class in _webhook_registry.keys():
-        # Disconnect signals for the model class
-        post_save.disconnect(
-            webhook_post_save,
-            sender=model_class,
-            dispatch_uid=f'webhook_post_save_{model_class.__name__}',
-        )
-        post_delete.disconnect(
-            webhook_post_delete,
-            sender=model_class,
-            dispatch_uid=f'webhook_post_delete_{model_class.__name__}',
-        )
-
-    return _webhook_registry
+    token = _webhooks_disabled.set(True)
+    try:
+        yield
+    finally:
+        _webhooks_disabled.reset(token)
+
+
+# =============================================================================
+# ContentType caching
+# =============================================================================
+
+
+@lru_cache(maxsize=128)
+def get_content_type_id(app_label, model_name) -> int:
+    """Cached lookup for content type ID"""
+
+    from django.contrib.contenttypes.models import ContentType
+
+    try:
+        return ContentType.objects.get(
+            app_label=app_label,
+            model=model_name,
+        ).id
+    except ContentType.DoesNotExist:
+        return None
+
+
+def clear_content_type_cache():
+    """Clear the content type cache"""
+
+    get_content_type_id.cache_clear()

django_webhook_subscriber/validators.py

@@ -0,0 +1,53 @@
+"""Validators for Django Webhook Subscriber."""
+
+from django.core.exceptions import ValidationError
+from django.utils.module_loading import import_string
+from rest_framework import serializers
+
+
+def validate_class_path(value):
+    """Validator to check if the class path points to a valid class."""
+
+    # Allow empty values
+    if not value:
+        return
+
+    try:
+        serializer_class = import_string(value)
+        # Check that the serializer_class is a rest_framework serializer
+        if not issubclass(serializer_class, serializers.Serializer):
+            raise ValueError(
+                "field_serializer must be a subclass of "
+                f"{serializers.Serializer}."
+            )
+
+    except ImportError as e:
+        raise ValidationError(f"Cannot import class from path: {value}") from e
+    except (TypeError, AttributeError) as e:
+        # Handles cases where imported object is not a class
+        raise ValidationError(
+            f"Path '{value}' does not point to a valid class"
+        ) from e
+
+
+def validate_headers(value):
+    """
+    Validator to ensure headers is a dict with string keys and string values.
+    """
+
+    if not isinstance(value, dict):
+        raise ValidationError("Headers must be a dictionary.")
+
+    for key, val in value.items():
+        if not isinstance(key, str):
+            raise ValidationError(f"Header key '{key}' must be a string.")
+
+        # Allow string or None values (some headers might be empty)
+        if val is not None and not isinstance(val, str):
+            raise ValidationError(
+                f"Header value for '{key}' must be a string or None."
+            )
+
+        # Optional: validate header name format (HTTP spec)
+        if not key.replace("-", "").replace("_", "").isalnum():
+            raise ValidationError(f"Invalid header name format: '{key}'")