rename type to group and fix serializer

Author: ameliahsu

src/sentry/workflow_engine/endpoints/organization_data_condition_index.py

@@ -1,5 +1,3 @@
-from typing import NotRequired, TypedDict
-
 from drf_spectacular.utils import extend_schema
 from rest_framework import serializers
 
@@ -17,19 +15,15 @@
 )
 from sentry.apidocs.parameters import GlobalParams
 from sentry.apidocs.utils import inline_sentry_response_serializer
-from sentry.workflow_engine.endpoints.serializers import DataConditionHandlerSerializer
+from sentry.workflow_engine.endpoints.serializers import (
+    DataConditionHandlerResponse,
+    DataConditionHandlerSerializer,
+)
 from sentry.workflow_engine.models.data_condition import LEGACY_CONDITIONS
 from sentry.workflow_engine.registry import condition_handler_registry
 from sentry.workflow_engine.types import DataConditionHandler
 
 
-class DataConditionHandlerResponse(TypedDict):
-    condition_id: str
-    type: str
-    filter_group: NotRequired[str]
-    comparison_json_schema: dict
-
-
 @region_silo_endpoint
 class OrganizationDataConditionIndexEndpoint(OrganizationEndpoint):
     publish_status = {
@@ -56,22 +50,23 @@ def get(self, request, organization):
         """
         Returns a list of data conditions for a given org
         """
-        type = request.GET.get("type")
+        group = request.GET.get("group")
         try:
-            DataConditionHandler.Type(type)
+            DataConditionHandler.Group(group)
         except ValueError:
             raise serializers.ValidationError("Invalid group")
 
         data_conditions = []
 
         for condition, handler in condition_handler_registry.registrations.items():
-            if condition not in LEGACY_CONDITIONS and handler.type == type:
-                condition_json = {"condition_id": condition}
-
-                condition_json.update(
-                    serialize(handler, request.user, DataConditionHandlerSerializer())
+            if condition not in LEGACY_CONDITIONS and handler.group == group:
+                serialized = serialize(
+                    handler,
+                    request.user,
+                    DataConditionHandlerSerializer(),
+                    condition_type=condition,
                 )
-                data_conditions.append(condition_json)
+                data_conditions.append(serialized)
 
         return self.paginate(
             request=request,

src/sentry/workflow_engine/endpoints/serializers.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from collections.abc import Mapping, MutableMapping, Sequence
-from typing import Any, TypedDict
+from typing import Any, NotRequired, TypedDict
 
 from sentry.api.serializers import Serializer, register, serialize
 from sentry.grouping.grouptype import ErrorGroupType
@@ -132,15 +132,25 @@ def serialize(
         }
 
 
+class DataConditionHandlerResponse(TypedDict):
+    type: str
+    handler_group: str
+    handler_subgroup: NotRequired[str]
+    comparison_json_schema: dict
+
+
 @register(DataConditionHandler)
 class DataConditionHandlerSerializer(Serializer):
-    def serialize(self, obj: DataConditionHandler, *args, **kwargs) -> dict[str, Any]:
+    def serialize(
+        self, obj: DataConditionHandler, *args, condition_type: str, **kwargs
+    ) -> DataConditionHandlerResponse:
         result = {
-            "type": obj.type.value,
+            "type": condition_type,
+            "handler_group": obj.group.value,
             "comparison_json_schema": obj.comparison_json_schema,
         }
-        if hasattr(obj, "filter_group"):
-            result["filter_group"] = obj.filter_group.value
+        if hasattr(obj, "subgroup"):
+            result["handler_subgroup"] = obj.subgroup.value
         return result
 
 

tests/sentry/workflow_engine/endpoints/test_organization_data_condition_index.py

@@ -24,14 +24,14 @@ def setUp(self):
         @self.registry.register(Condition.REAPPEARED_EVENT)
         @dataclass(frozen=True)
         class TestWorkflowTrigger(DataConditionHandler):
-            type = DataConditionHandler.Type.WORKFLOW_TRIGGER
+            group = DataConditionHandler.Group.WORKFLOW_TRIGGER
             comparison_json_schema = {"type": "boolean"}
 
         @self.registry.register(Condition.AGE_COMPARISON)
         @dataclass(frozen=True)
         class TestActionFilter(DataConditionHandler):
-            type = DataConditionHandler.Type.ACTION_FILTER
-            filter_group = DataConditionHandler.FilterGroup.ISSUE_ATTRIBUTES
+            group = DataConditionHandler.Group.ACTION_FILTER
+            subgroup = DataConditionHandler.Subgroup.ISSUE_ATTRIBUTES
             comparison_json_schema = {
                 "type": "object",
                 "properties": {
@@ -44,14 +44,14 @@ class TestActionFilter(DataConditionHandler):
         @self.registry.register(Condition.ANOMALY_DETECTION)
         @dataclass(frozen=True)
         class TestDetectorTrigger(DataConditionHandler):
-            type = DataConditionHandler.Type.DETECTOR_TRIGGER
+            group = DataConditionHandler.Group.DETECTOR_TRIGGER
             comparison_json_schema = {"type": "boolean"}
 
         # This condition should not be included in the response
         @self.registry.register(Condition.EVERY_EVENT)
         @dataclass(frozen=True)
         class TestIgnoredCondition(DataConditionHandler):
-            type = DataConditionHandler.Type.WORKFLOW_TRIGGER
+            group = DataConditionHandler.Group.WORKFLOW_TRIGGER
             comparison_json_schema = {"type": "boolean"}
 
     def tearDown(self) -> None:
@@ -61,25 +61,25 @@ def tearDown(self) -> None:
 
 @region_silo_test
 class OrganizationDataCondiitonIndexBaseTest(OrganizationDataConditionAPITestCase):
-    def test_type_filter(self):
+    def test_group_filter(self):
         response = self.get_success_response(
-            self.organization.slug, type=DataConditionHandler.Type.WORKFLOW_TRIGGER
+            self.organization.slug, group=DataConditionHandler.Group.WORKFLOW_TRIGGER
         )
         assert len(response.data) == 1
         assert response.data[0] == {
-            "condition_id": Condition.REAPPEARED_EVENT.value,
-            "type": DataConditionHandler.Type.WORKFLOW_TRIGGER.value,
+            "type": Condition.REAPPEARED_EVENT.value,
+            "handler_group": DataConditionHandler.Group.WORKFLOW_TRIGGER.value,
             "comparison_json_schema": {"type": "boolean"},
         }
 
         response = self.get_success_response(
-            self.organization.slug, type=DataConditionHandler.Type.ACTION_FILTER, status_code=200
+            self.organization.slug, group=DataConditionHandler.Group.ACTION_FILTER, status_code=200
         )
         assert len(response.data) == 1
         assert response.data[0] == {
-            "condition_id": Condition.AGE_COMPARISON.value,
-            "type": DataConditionHandler.Type.ACTION_FILTER.value,
-            "filter_group": DataConditionHandler.FilterGroup.ISSUE_ATTRIBUTES.value,
+            "type": Condition.AGE_COMPARISON.value,
+            "handler_group": DataConditionHandler.Group.ACTION_FILTER.value,
+            "handler_subgroup": DataConditionHandler.Subgroup.ISSUE_ATTRIBUTES.value,
             "comparison_json_schema": {
                 "type": "object",
                 "properties": {
@@ -90,8 +90,8 @@ def test_type_filter(self):
             },
         }
 
-    def test_invalid_type(self):
-        self.get_error_response(self.organization.slug, type="invalid", status_code=400)
+    def test_invalid_group(self):
+        self.get_error_response(self.organization.slug, group="invalid", status_code=400)
 
-    def test_no_type(self):
+    def test_no_group(self):
         self.get_error_response(self.organization.slug, status_code=400)