vellum-ai 1.7.11__py3-none-any.whl → 1.7.13__py3-none-any.whl

vellum/workflows/tests/triggers/test_vellum_integration_trigger.py

@@ -1,4 +1,4 @@
-"""Tests for VellumIntegrationTrigger factory pattern and behavior."""
+"""Tests for VellumIntegrationTrigger."""
 
 import pytest
 
@@ -7,46 +7,101 @@ from vellum.workflows.references.trigger import TriggerAttributeReference
 from vellum.workflows.triggers.vellum_integration import VellumIntegrationTrigger
 
 
-def test_factory_creates_trigger_class() -> None:
-    """Factory method creates a trigger class with correct attributes."""
-    SlackNewMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-        attributes={"channel": "C123456"},
-    )
-
-    assert issubclass(SlackNewMessage, VellumIntegrationTrigger)
-    assert SlackNewMessage.provider == VellumIntegrationProviderType.COMPOSIO
-    assert SlackNewMessage.integration_name == "SLACK"
-    assert SlackNewMessage.slug == "slack_new_message"
-    assert SlackNewMessage.trigger_nano_id == "test_nano_123"
-    assert SlackNewMessage.attributes == {"channel": "C123456"}
-
-
-def test_factory_caches_trigger_classes() -> None:
-    """Factory returns the same class instance for identical parameters (ensures deterministic UUIDs)."""
-    SlackNewMessage1 = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-    SlackNewMessage2 = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-
-    assert SlackNewMessage1 is SlackNewMessage2
-
-
-def test_populates_dynamic_attributes() -> None:
+def test_requires_config():
+    """Trigger classes must declare Config with required fields."""
+
+    # This should fail - no Config class
+    with pytest.raises(TypeError, match="Config"):
+
+        class BadTrigger1(VellumIntegrationTrigger):
+            message: str
+            # Missing Config!
+
+    # This should fail - incomplete Config
+    with pytest.raises(TypeError, match="provider"):
+
+        class BadTrigger2(VellumIntegrationTrigger):
+            message: str
+
+            class Config(VellumIntegrationTrigger.Config):
+                integration_name = "SLACK"
+                slug = "slack_new_message"
+                # Missing provider!
+
+    # This should work
+    class GoodTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    assert hasattr(GoodTrigger, "Config")
+
+
+def test_top_level_annotations_create_references():
+    """Top-level type annotations (webhook event attributes) automatically create TriggerAttributeReference."""
+
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
+        timestamp: float
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # Should auto-create references from annotations
+    assert isinstance(SlackTrigger.message, TriggerAttributeReference)
+    assert isinstance(SlackTrigger.user, TriggerAttributeReference)
+    assert isinstance(SlackTrigger.timestamp, TriggerAttributeReference)
+    assert SlackTrigger.message.types == (str,)
+    assert SlackTrigger.timestamp.types == (float,)
+
+    # Undeclared attributes should raise AttributeError
+    with pytest.raises(AttributeError):
+        _ = SlackTrigger.undefined_attribute
+
+
+def test_attribute_ids_include_class_name():
+    """Attribute IDs should include class name (like nodes)."""
+
+    class Trigger1(VellumIntegrationTrigger):
+        message: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    class Trigger2(VellumIntegrationTrigger):
+        message: str
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
+
+    # Different class names = different IDs (like nodes)
+    # Type ignore: mypy sees message as str, but it's actually TriggerAttributeReference at class level
+    assert Trigger1.message.id != Trigger2.message.id  # type: ignore[attr-defined]
+
+
+def test_populates_dynamic_attributes():
     """Trigger dynamically populates attributes from event_data keys."""
-    GithubPush = VellumIntegrationTrigger.for_trigger(
-        integration_name="GITHUB",
-        slug="github_push_event",
-        trigger_nano_id="test_nano_456",
-    )
+
+    class GithubPushTrigger(VellumIntegrationTrigger):
+        repository: str
+        branch: str
+        commits: list
+
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "GITHUB"
+            slug = "github_push_event"
 
     event_data = {
         "repository": "vellum-ai/workflows",
@@ -54,41 +109,27 @@ def test_populates_dynamic_attributes() -> None:
         "commits": ["abc123", "def456"],
     }
 
-    trigger = GithubPush(event_data=event_data)
+    trigger = GithubPushTrigger(event_data=event_data)
 
-    assert getattr(trigger, "repository") == "vellum-ai/workflows"
-    assert getattr(trigger, "branch") == "main"
-    assert getattr(trigger, "commits") == ["abc123", "def456"]
+    assert trigger.repository == "vellum-ai/workflows"
+    assert trigger.branch == "main"
+    assert trigger.commits == ["abc123", "def456"]
 
 
-def test_supports_attribute_references() -> None:
-    """Metaclass creates TriggerAttributeReference dynamically on attribute access."""
-    SlackNewMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-
-    # Metaclass __getattribute__ creates references for undefined attributes
-    message_ref = SlackNewMessage.message
-    channel_ref = SlackNewMessage.channel
+def test_to_trigger_attribute_values():
+    """to_trigger_attribute_values returns correct attribute mappings."""
 
-    assert isinstance(message_ref, TriggerAttributeReference)
-    assert isinstance(channel_ref, TriggerAttributeReference)
-    assert message_ref.name == "message"
-    assert channel_ref.name == "channel"
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        channel: str
 
-
-def test_to_trigger_attribute_values() -> None:
-    """to_trigger_attribute_values returns correct attribute mappings."""
-    SlackNewMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
 
     event_data = {"message": "Hello", "channel": "C123"}
-    trigger = SlackNewMessage(event_data=event_data)
+    trigger = SlackTrigger(event_data=event_data)
 
     attr_values = trigger.to_trigger_attribute_values()
 
@@ -98,128 +139,45 @@ def test_to_trigger_attribute_values() -> None:
     assert set(attr_values.values()) == {"Hello", "C123"}
 
 
-def test_trigger_attribute_id_stability() -> None:
-    """Trigger attribute IDs must be stable across factory calls."""
-    Slack1 = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-    Slack2 = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-
-    # Factory caching ensures same class
-    assert Slack1 is Slack2
-
-    # Attribute references must be deterministic across accesses
-    msg_ref_1 = Slack1.message
-    msg_ref_2 = Slack2.message
+def test_to_exec_config():
+    """to_exec_config() produces valid ComposioIntegrationTriggerExecConfig."""
 
-    # Same trigger class + same attribute name = same reference
-    assert msg_ref_1 == msg_ref_2
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
+        user: str
 
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
 
-def test_to_exec_config() -> None:
-    """to_exec_config() produces valid ComposioIntegrationTriggerExecConfig."""
-    SlackMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="abc123def456",
-        attributes={"channel": "C123456"},
-    )
+    exec_config = SlackTrigger.to_exec_config()
 
-    exec_config = SlackMessage.to_exec_config()
-
-    assert exec_config.type == "COMPOSIO_INTEGRATION_TRIGGER"
+    assert exec_config.type == "INTEGRATION"
     assert exec_config.provider == VellumIntegrationProviderType.COMPOSIO
     assert exec_config.integration_name == "SLACK"
     assert exec_config.slug == "slack_new_message"
-    assert exec_config.trigger_nano_id == "abc123def456"
-    assert exec_config.attributes == {"channel": "C123456"}
+    assert exec_config.event_attributes == {"message": str, "user": str}
 
 
-def test_to_exec_config_base_class_fails() -> None:
+def test_to_exec_config_base_class_fails():
     """to_exec_config() raises error on base class."""
-    with pytest.raises(AttributeError, match="factory-generated trigger classes"):
+    with pytest.raises(AttributeError):
         VellumIntegrationTrigger.to_exec_config()
 
 
-def test_empty_event_data() -> None:
+def test_empty_event_data():
     """Trigger handles empty event data gracefully."""
-    SlackMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-    trigger = SlackMessage(event_data={})
 
-    attr_values = trigger.to_trigger_attribute_values()
-    assert attr_values == {}
+    class SlackTrigger(VellumIntegrationTrigger):
+        message: str
 
+        class Config(VellumIntegrationTrigger.Config):
+            provider = VellumIntegrationProviderType.COMPOSIO
+            integration_name = "SLACK"
+            slug = "slack_new_message"
 
-def test_attribute_name_does_not_conflict_with_class_variables() -> None:
-    """Event data attributes don't conflict with class variables."""
-    SlackMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-    )
-
-    # Event data with key that matches a class variable name
-    event_data = {"provider": "some_value", "message": "Hello"}
-    trigger = SlackMessage(event_data=event_data)
-
-    # Instance attribute should be set from event_data
-    assert trigger.provider == "some_value"  # Instance attr from event_data
-    # But class variable should be unchanged
-    assert SlackMessage.provider == VellumIntegrationProviderType.COMPOSIO
-
-
-def test_non_json_serializable_attributes_fail_fast() -> None:
-    """Non-JSON-serializable attributes raise ValueError with clear message."""
-
-    # Custom objects are not JSON-serializable
-    class CustomObject:
-        pass
-
-    with pytest.raises(ValueError, match="must be JSON-serializable"):
-        VellumIntegrationTrigger.for_trigger(
-            integration_name="SLACK",
-            slug="slack_new_message",
-            trigger_nano_id="test_nano_123",
-            attributes={"custom": CustomObject()},
-        )
-
-    # Sets are not JSON-serializable
-    with pytest.raises(ValueError, match="must be JSON-serializable"):
-        VellumIntegrationTrigger.for_trigger(
-            integration_name="SLACK",
-            slug="slack_new_message",
-            trigger_nano_id="test_nano_123",
-            attributes={"tags": {"a", "b", "c"}},
-        )
-
-
-def test_nested_json_serializable_attributes_work() -> None:
-    """Nested JSON-serializable attributes work correctly."""
-    SlackMessage = VellumIntegrationTrigger.for_trigger(
-        integration_name="SLACK",
-        slug="slack_new_message",
-        trigger_nano_id="test_nano_123",
-        attributes={
-            "channel": "C123456",
-            "filters": {"status": "active", "priority": ["high", "medium"]},
-            "count": 42,
-            "enabled": True,
-        },
-    )
-
-    assert SlackMessage.attributes == {
-        "channel": "C123456",
-        "filters": {"status": "active", "priority": ["high", "medium"]},
-        "count": 42,
-        "enabled": True,
-    }
+    trigger = SlackTrigger(event_data={})
+
+    attr_values = trigger.to_trigger_attribute_values()
+    assert attr_values == {}

vellum/workflows/triggers/__init__.py

@@ -1,7 +1,6 @@
 from vellum.workflows.triggers.base import BaseTrigger
 from vellum.workflows.triggers.integration import IntegrationTrigger
 from vellum.workflows.triggers.manual import ManualTrigger
-from vellum.workflows.triggers.slack import SlackTrigger
 from vellum.workflows.triggers.vellum_integration import VellumIntegrationTrigger
 
-__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger", "SlackTrigger", "VellumIntegrationTrigger"]
+__all__ = ["BaseTrigger", "IntegrationTrigger", "ManualTrigger", "VellumIntegrationTrigger"]

vellum/workflows/triggers/tests/test_integration.py

@@ -57,8 +57,8 @@ def test_integration_trigger__attribute_reference():
     reference = TestTrigger.value
     assert isinstance(reference, TriggerAttributeReference)
     assert reference.name == "value"
-    assert TestTrigger.value is reference
-    assert reference is TestTrigger.attribute_references()["value"]
+    assert TestTrigger.value == reference
+    assert reference == TestTrigger.attribute_references()["value"]
 
     state = BaseState()
     trigger = TestTrigger({"value": "data"})