webhook-platform 1.0.0__py3-none-any.whl

tests/test_client.py

@@ -0,0 +1,288 @@
+"""Tests for WebhookPlatform client."""
+
+import pytest
+
+from webhook_platform import (
+    WebhookPlatform,
+    WebhookPlatformError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    NotFoundError,
+    Event,
+    EventResponse,
+    Endpoint,
+    EndpointCreateParams,
+    EndpointUpdateParams,
+    Subscription,
+    SubscriptionCreateParams,
+    Delivery,
+    DeliveryAttempt,
+    DeliveryListParams,
+    PaginatedResponse,
+    RateLimitInfo,
+)
+
+
+class TestWebhookPlatformClient:
+    """Tests for WebhookPlatform client initialization."""
+
+    def test_creates_with_api_key(self):
+        """Should create client with API key."""
+        client = WebhookPlatform(api_key="test_api_key")
+        assert client is not None
+        assert client.api_key == "test_api_key"
+
+    def test_raises_without_api_key(self):
+        """Should raise error without API key."""
+        with pytest.raises(ValueError) as exc:
+            WebhookPlatform(api_key="")
+        assert "API key is required" in str(exc.value)
+
+    def test_uses_default_base_url(self):
+        """Should use default base URL."""
+        client = WebhookPlatform(api_key="test_api_key")
+        assert client.base_url == "http://localhost:8080"
+
+    def test_accepts_custom_base_url(self):
+        """Should accept custom base URL."""
+        client = WebhookPlatform(
+            api_key="test_api_key",
+            base_url="https://api.example.com/",
+        )
+        assert client.base_url == "https://api.example.com"
+
+    def test_strips_trailing_slash(self):
+        """Should strip trailing slash from base URL."""
+        client = WebhookPlatform(
+            api_key="test_api_key",
+            base_url="https://api.example.com/",
+        )
+        assert not client.base_url.endswith("/")
+
+    def test_accepts_custom_timeout(self):
+        """Should accept custom timeout."""
+        client = WebhookPlatform(api_key="test_api_key", timeout=60)
+        assert client.timeout == 60
+
+    def test_initializes_api_modules(self):
+        """Should initialize all API modules."""
+        client = WebhookPlatform(api_key="test_api_key")
+        assert client.events is not None
+        assert client.endpoints is not None
+        assert client.subscriptions is not None
+        assert client.deliveries is not None
+
+
+class TestErrorClasses:
+    """Tests for error classes."""
+
+    def test_webhook_platform_error(self):
+        """WebhookPlatformError should have correct properties."""
+        error = WebhookPlatformError("Test error", 500, "test_code")
+        assert error.message == "Test error"
+        assert error.status == 500
+        assert error.code == "test_code"
+        assert "Test error" in str(error)
+
+    def test_authentication_error_defaults(self):
+        """AuthenticationError should have correct defaults."""
+        error = AuthenticationError()
+        assert error.message == "Invalid API key"
+        assert error.status == 401
+        assert error.code == "authentication_error"
+
+    def test_authentication_error_custom_message(self):
+        """AuthenticationError should accept custom message."""
+        error = AuthenticationError("Custom auth error")
+        assert error.message == "Custom auth error"
+
+    def test_rate_limit_error(self):
+        """RateLimitError should have rate limit info."""
+        info = RateLimitInfo(limit=100, remaining=0, reset=1700000000000)
+        error = RateLimitError("Rate limit exceeded", info)
+        assert error.status == 429
+        assert error.code == "rate_limit_exceeded"
+        assert error.rate_limit_info.limit == 100
+
+    def test_validation_error(self):
+        """ValidationError should have field errors."""
+        field_errors = {"email": "Invalid email", "url": "Invalid URL"}
+        error = ValidationError("Validation failed", field_errors)
+        assert error.status == 400
+        assert error.code == "validation_error"
+        assert error.field_errors == field_errors
+
+    def test_validation_error_empty_fields(self):
+        """ValidationError should default to empty field errors."""
+        error = ValidationError("Validation failed")
+        assert error.field_errors == {}
+
+    def test_not_found_error(self):
+        """NotFoundError should have correct defaults."""
+        error = NotFoundError()
+        assert error.message == "Resource not found"
+        assert error.status == 404
+        assert error.code == "not_found"
+
+
+class TestTypeClasses:
+    """Tests for type/model classes."""
+
+    def test_event_creation(self):
+        """Event should be created correctly."""
+        event = Event(type="order.completed", data={"orderId": "123"})
+        assert event.type == "order.completed"
+        assert event.data == {"orderId": "123"}
+
+    def test_event_response_from_dict(self):
+        """EventResponse should parse from dict correctly."""
+        data = {
+            "eventId": "evt_123",
+            "type": "order.completed",
+            "createdAt": "2024-01-01T00:00:00Z",
+            "deliveriesCreated": 3,
+        }
+        response = EventResponse.from_dict(data)
+        assert response.event_id == "evt_123"
+        assert response.type == "order.completed"
+        assert response.deliveries_created == 3
+
+    def test_endpoint_from_dict(self):
+        """Endpoint should parse from dict correctly."""
+        data = {
+            "id": "ep_123",
+            "url": "https://example.com/webhook",
+            "secret": "whsec_abc",
+            "enabled": True,
+            "createdAt": "2024-01-01T00:00:00Z",
+            "description": "Test endpoint",
+            "rateLimitPerSecond": 10,
+        }
+        endpoint = Endpoint.from_dict(data)
+        assert endpoint.id == "ep_123"
+        assert endpoint.url == "https://example.com/webhook"
+        assert endpoint.secret == "whsec_abc"
+        assert endpoint.enabled is True
+        assert endpoint.description == "Test endpoint"
+        assert endpoint.rate_limit_per_second == 10
+
+    def test_endpoint_create_params_to_dict(self):
+        """EndpointCreateParams should convert to dict correctly."""
+        params = EndpointCreateParams(
+            url="https://example.com/webhook",
+            description="Test",
+            enabled=True,
+            rate_limit_per_second=10,
+        )
+        data = params.to_dict()
+        assert data["url"] == "https://example.com/webhook"
+        assert data["description"] == "Test"
+        assert data["enabled"] is True
+        assert data["rateLimitPerSecond"] == 10
+
+    def test_endpoint_update_params_to_dict(self):
+        """EndpointUpdateParams should only include set fields."""
+        params = EndpointUpdateParams(url="https://new-url.com")
+        data = params.to_dict()
+        assert data == {"url": "https://new-url.com"}
+
+    def test_subscription_from_dict(self):
+        """Subscription should parse from dict correctly."""
+        data = {
+            "id": "sub_123",
+            "endpointId": "ep_456",
+            "eventTypes": ["order.completed", "order.cancelled"],
+            "enabled": True,
+            "createdAt": "2024-01-01T00:00:00Z",
+        }
+        subscription = Subscription.from_dict(data)
+        assert subscription.id == "sub_123"
+        assert subscription.endpoint_id == "ep_456"
+        assert subscription.event_types == ["order.completed", "order.cancelled"]
+
+    def test_subscription_create_params_to_dict(self):
+        """SubscriptionCreateParams should convert to dict correctly."""
+        params = SubscriptionCreateParams(
+            endpoint_id="ep_123",
+            event_types=["order.completed"],
+            enabled=True,
+        )
+        data = params.to_dict()
+        assert data["endpointId"] == "ep_123"
+        assert data["eventTypes"] == ["order.completed"]
+        assert data["enabled"] is True
+
+    def test_delivery_from_dict(self):
+        """Delivery should parse from dict correctly."""
+        data = {
+            "id": "dlv_123",
+            "eventId": "evt_456",
+            "endpointId": "ep_789",
+            "status": "SUCCESS",
+            "attemptCount": 1,
+            "maxAttempts": 7,
+            "createdAt": "2024-01-01T00:00:00Z",
+            "succeededAt": "2024-01-01T00:00:01Z",
+        }
+        delivery = Delivery.from_dict(data)
+        assert delivery.id == "dlv_123"
+        assert delivery.event_id == "evt_456"
+        assert delivery.status.value == "SUCCESS"
+        assert delivery.attempt_count == 1
+
+    def test_delivery_attempt_from_dict(self):
+        """DeliveryAttempt should parse from dict correctly."""
+        data = {
+            "id": "att_123",
+            "attemptNumber": 1,
+            "httpStatus": 200,
+            "responseBody": "OK",
+            "latencyMs": 150,
+            "attemptedAt": "2024-01-01T00:00:00Z",
+        }
+        attempt = DeliveryAttempt.from_dict(data)
+        assert attempt.id == "att_123"
+        assert attempt.attempt_number == 1
+        assert attempt.http_status == 200
+        assert attempt.latency_ms == 150
+
+    def test_delivery_list_params_to_params(self):
+        """DeliveryListParams should convert to query params correctly."""
+        from webhook_platform.types import DeliveryStatus
+        
+        params = DeliveryListParams(
+            status=DeliveryStatus.FAILED,
+            endpoint_id="ep_123",
+            page=1,
+            size=50,
+        )
+        query_params = params.to_params()
+        assert query_params["status"] == "FAILED"
+        assert query_params["endpointId"] == "ep_123"
+        assert query_params["page"] == 1
+        assert query_params["size"] == 50
+
+    def test_paginated_response_from_dict(self):
+        """PaginatedResponse should parse from dict correctly."""
+        data = {
+            "content": [
+                {
+                    "id": "dlv_1",
+                    "eventId": "evt_1",
+                    "endpointId": "ep_1",
+                    "status": "SUCCESS",
+                    "attemptCount": 1,
+                    "maxAttempts": 7,
+                    "createdAt": "2024-01-01T00:00:00Z",
+                }
+            ],
+            "totalElements": 100,
+            "totalPages": 5,
+            "size": 20,
+            "number": 0,
+        }
+        response = PaginatedResponse.from_dict(data)
+        assert len(response.content) == 1
+        assert response.total_elements == 100
+        assert response.total_pages == 5

tests/test_webhooks.py

@@ -0,0 +1,264 @@
+"""Tests for webhook signature verification."""
+
+import json
+import time
+import pytest
+
+from webhook_platform import (
+    verify_signature,
+    construct_event,
+    generate_signature,
+    WebhookPlatformError,
+)
+
+
+class TestGenerateSignature:
+    """Tests for generate_signature function."""
+
+    def test_generates_valid_format(self):
+        """Should generate signature in correct format."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        
+        signature = generate_signature(payload, secret)
+        
+        assert signature.startswith("t=")
+        assert ",v1=" in signature
+        parts = signature.split(",")
+        assert len(parts) == 2
+
+    def test_uses_provided_timestamp(self):
+        """Should use provided timestamp."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        timestamp = 1700000000000
+        
+        signature = generate_signature(payload, secret, timestamp)
+        
+        assert f"t={timestamp}" in signature
+
+    def test_consistent_signatures(self):
+        """Should generate consistent signatures for same inputs."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        timestamp = 1700000000000
+        
+        sig1 = generate_signature(payload, secret, timestamp)
+        sig2 = generate_signature(payload, secret, timestamp)
+        
+        assert sig1 == sig2
+
+    def test_different_payloads_different_signatures(self):
+        """Different payloads should produce different signatures."""
+        secret = "whsec_test_secret"
+        timestamp = 1700000000000
+        
+        sig1 = generate_signature('{"a": 1}', secret, timestamp)
+        sig2 = generate_signature('{"b": 2}', secret, timestamp)
+        
+        assert sig1 != sig2
+
+    def test_different_secrets_different_signatures(self):
+        """Different secrets should produce different signatures."""
+        payload = '{"type": "test"}'
+        timestamp = 1700000000000
+        
+        sig1 = generate_signature(payload, "secret1", timestamp)
+        sig2 = generate_signature(payload, "secret2", timestamp)
+        
+        assert sig1 != sig2
+
+
+class TestVerifySignature:
+    """Tests for verify_signature function."""
+
+    def test_verifies_valid_signature(self):
+        """Should verify a valid signature."""
+        payload = '{"type": "order.completed", "data": {"id": "123"}}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        signature = generate_signature(payload, secret, timestamp)
+        
+        assert verify_signature(payload, signature, secret) is True
+
+    def test_raises_on_missing_signature(self):
+        """Should raise on missing signature."""
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature("payload", "", "secret")
+        
+        assert "Missing signature header" in str(exc.value)
+        assert exc.value.code == "invalid_signature"
+
+    def test_raises_on_invalid_format(self):
+        """Should raise on invalid signature format."""
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature("payload", "invalid_format", "secret")
+        
+        assert "Invalid signature format" in str(exc.value)
+
+    def test_raises_on_missing_timestamp(self):
+        """Should raise when timestamp is missing."""
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature("payload", "v1=abc123", "secret")
+        
+        assert "Invalid signature format" in str(exc.value)
+
+    def test_raises_on_missing_v1(self):
+        """Should raise when v1 signature is missing."""
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature("payload", "t=1700000000000", "secret")
+        
+        assert "Invalid signature format" in str(exc.value)
+
+    def test_raises_on_expired_timestamp(self):
+        """Should raise on expired timestamp."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        old_timestamp = int(time.time() * 1000) - 600000  # 10 min ago
+        signature = generate_signature(payload, secret, old_timestamp)
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature(payload, signature, secret)
+        
+        assert "outside tolerance window" in str(exc.value)
+        assert exc.value.code == "timestamp_expired"
+
+    def test_raises_on_future_timestamp(self):
+        """Should raise on future timestamp outside tolerance."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        future_timestamp = int(time.time() * 1000) + 600000  # 10 min in future
+        signature = generate_signature(payload, secret, future_timestamp)
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature(payload, signature, secret)
+        
+        assert "outside tolerance window" in str(exc.value)
+
+    def test_accepts_timestamp_within_tolerance(self):
+        """Should accept timestamp within tolerance."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        recent_timestamp = int(time.time() * 1000) - 60000  # 1 min ago
+        signature = generate_signature(payload, secret, recent_timestamp)
+        
+        assert verify_signature(payload, signature, secret) is True
+
+    def test_raises_on_invalid_signature(self):
+        """Should raise on invalid signature value."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature(payload, f"t={timestamp},v1=invalid", secret)
+        
+        assert "Invalid signature" in str(exc.value)
+
+    def test_raises_on_tampered_payload(self):
+        """Should raise when payload is tampered."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        signature = generate_signature(payload, secret, timestamp)
+        
+        tampered = '{"type": "hacked"}'
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            verify_signature(tampered, signature, secret)
+        
+        assert "Invalid signature" in str(exc.value)
+
+    def test_respects_custom_tolerance(self):
+        """Should respect custom tolerance setting."""
+        payload = '{"type": "test"}'
+        secret = "whsec_test_secret"
+        old_timestamp = int(time.time() * 1000) - 60000  # 1 min ago
+        signature = generate_signature(payload, secret, old_timestamp)
+        
+        # Should fail with 30s tolerance
+        with pytest.raises(WebhookPlatformError):
+            verify_signature(payload, signature, secret, tolerance_ms=30000)
+        
+        # Should pass with 2min tolerance
+        assert verify_signature(payload, signature, secret, tolerance_ms=120000) is True
+
+
+class TestConstructEvent:
+    """Tests for construct_event function."""
+
+    def test_constructs_event_from_valid_request(self):
+        """Should construct event from valid request."""
+        payload = '{"type": "order.completed", "data": {"orderId": "123"}}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        signature = generate_signature(payload, secret, timestamp)
+        
+        headers = {
+            "x-signature": signature,
+            "x-timestamp": str(timestamp),
+            "x-event-id": "evt_123",
+            "x-delivery-id": "dlv_456",
+        }
+        
+        event = construct_event(payload, headers, secret)
+        
+        assert event.event_id == "evt_123"
+        assert event.delivery_id == "dlv_456"
+        assert event.timestamp == timestamp
+        assert event.type == "order.completed"
+        assert event.data == {"orderId": "123"}
+
+    def test_handles_uppercase_headers(self):
+        """Should handle uppercase headers."""
+        payload = '{"type": "test", "data": {}}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        signature = generate_signature(payload, secret, timestamp)
+        
+        headers = {
+            "X-Signature": signature,
+            "X-Timestamp": str(timestamp),
+            "X-Event-Id": "evt_123",
+        }
+        
+        event = construct_event(payload, headers, secret)
+        
+        assert event.event_id == "evt_123"
+
+    def test_raises_on_missing_signature(self):
+        """Should raise on missing signature header."""
+        headers = {"x-timestamp": "1700000000000"}
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            construct_event('{"type": "test"}', headers, "secret")
+        
+        assert "Missing X-Signature header" in str(exc.value)
+
+    def test_raises_on_invalid_json(self):
+        """Should raise on invalid JSON payload."""
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        invalid_payload = "not valid json"
+        signature = generate_signature(invalid_payload, secret, timestamp)
+        
+        headers = {"x-signature": signature}
+        
+        with pytest.raises(WebhookPlatformError) as exc:
+            construct_event(invalid_payload, headers, secret)
+        
+        assert "Invalid JSON payload" in str(exc.value)
+
+    def test_handles_flat_payload(self):
+        """Should handle payload without nested data field."""
+        payload = '{"type": "test.event", "value": 123}'
+        secret = "whsec_test_secret"
+        timestamp = int(time.time() * 1000)
+        signature = generate_signature(payload, secret, timestamp)
+        
+        headers = {"x-signature": signature}
+        
+        event = construct_event(payload, headers, secret)
+        
+        assert event.type == "test.event"
+        assert event.data == {"type": "test.event", "value": 123}

webhook_platform/__init__.py

@@ -0,0 +1,54 @@
+"""Official Python SDK for Webhook Platform."""
+
+from .client import WebhookPlatform
+from .errors import (
+    WebhookPlatformError,
+    AuthenticationError,
+    RateLimitError,
+    ValidationError,
+    NotFoundError,
+)
+from .webhooks import verify_signature, construct_event, generate_signature
+from .types import (
+    Event,
+    EventResponse,
+    Endpoint,
+    EndpointCreateParams,
+    EndpointUpdateParams,
+    Subscription,
+    SubscriptionCreateParams,
+    Delivery,
+    DeliveryAttempt,
+    DeliveryListParams,
+    PaginatedResponse,
+    EndpointTestResult,
+    RateLimitInfo,
+    WebhookEvent,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "WebhookPlatform",
+    "WebhookPlatformError",
+    "AuthenticationError",
+    "RateLimitError",
+    "ValidationError",
+    "NotFoundError",
+    "verify_signature",
+    "construct_event",
+    "generate_signature",
+    "Event",
+    "EventResponse",
+    "Endpoint",
+    "EndpointCreateParams",
+    "EndpointUpdateParams",
+    "Subscription",
+    "SubscriptionCreateParams",
+    "Delivery",
+    "DeliveryAttempt",
+    "DeliveryListParams",
+    "PaginatedResponse",
+    "EndpointTestResult",
+    "RateLimitInfo",
+    "WebhookEvent",
+]