typing fix

Author: kcons

src/sentry/incidents/logic.py

@@ -929,10 +929,8 @@ def update_alert_rule(
             updated_fields["seasonality"] = None
         elif detection_type == AlertRuleDetectionType.DYNAMIC:
             # NOTE: we set seasonality for EA
-            updated_query_fields["resolution"] = (
-                timedelta(minutes=time_window)
-                if time_window is not None
-                else timedelta(seconds=snuba_query.time_window)
+            updated_query_fields["resolution"] = timedelta(
+                minutes=time_window if time_window is not None else snuba_query.time_window
             )
             updated_fields["seasonality"] = AlertRuleSeasonality.AUTO
             updated_fields["comparison_delta"] = None

src/sentry/incidents/metric_issue_detector.py

@@ -250,18 +250,21 @@ def _validate_extrapolation_mode(self, extrapolation_mode: ExtrapolationMode) ->
             )
 
     def _get_resolution_for_window(
-        self, time_window_seconds: int, detection_type: str | None, comparison_delta: int | None
+        self,
+        time_window_seconds: int | float,
+        detection_type: str | None,
+        comparison_delta: int | float | None,
     ) -> timedelta:
         """
-        Compute the appropriate SnubaQuery resolution for a given time window,
-        mirroring the logic in create_alert_rule / update_alert_rule.
+        Compute the appropriate SnubaQuery resolution for a given time window
+        (in seconds), mirroring the logic in create_alert_rule / update_alert_rule.
         """
         organization = self.context["organization"]
 
         if detection_type == AlertRuleDetectionType.DYNAMIC:
             resolution = timedelta(seconds=time_window_seconds)
         else:
-            resolution = get_alert_resolution(time_window_seconds // 60, organization)
+            resolution = get_alert_resolution(int(time_window_seconds) // 60, organization)
             if comparison_delta is not None:
                 resolution *= DEFAULT_CMP_ALERT_RULE_RESOLUTION_MULTIPLIER
 
@@ -294,7 +297,7 @@ def get_quota(self) -> DetectorQuota:
         return DetectorQuota(has_exceeded=has_exceeded, limit=detector_limit, count=detector_count)
 
     def is_editing_transaction_dataset(
-        self, snuba_query: SnubaQuery, data_source: SnubaQueryDataSourceType
+        self, snuba_query: SnubaQuery, data_source: SnubaQueryDataSourceType | dict[str, Any]
     ) -> bool:
         organization = self.context.get("organization")
         current_dataset = Dataset(snuba_query.dataset)
@@ -317,7 +320,10 @@ def is_editing_transaction_dataset(
         return False
 
     def update_data_source(
-        self, instance: Detector, data_source: SnubaQueryDataSourceType, seer_updated: bool = False
+        self,
+        instance: Detector,
+        data_source: SnubaQueryDataSourceType | dict[str, Any],
+        seer_updated: bool = False,
     ) -> None:
         try:
             source_instance = DataSource.objects.get(detector=instance)
@@ -334,7 +340,7 @@ def update_data_source(
             except SnubaQuery.DoesNotExist:
                 raise serializers.ValidationError("SnubaQuery not found, can't update")
 
-        event_types = SnubaQueryEventType.objects.filter(snuba_query_id=snuba_query.id)
+        event_types = snuba_query.event_types
 
         if self.is_editing_transaction_dataset(snuba_query, data_source):
             raise serializers.ValidationError(
@@ -373,14 +379,14 @@ def update_data_source(
 
         update_snuba_query(
             snuba_query=snuba_query,
-            query_type=data_source.get("query_type", snuba_query.type),
-            dataset=data_source.get("dataset", snuba_query.dataset),
+            query_type=data_source.get("query_type", SnubaQuery.Type(snuba_query.type)),
+            dataset=data_source.get("dataset", Dataset(snuba_query.dataset)),
             query=data_source.get("query", snuba_query.query),
             aggregate=data_source.get("aggregate", snuba_query.aggregate),
             time_window=timedelta(seconds=new_time_window),
             resolution=resolution,
             environment=data_source.get("environment", snuba_query.environment),
-            event_types=data_source.get("event_types", [event_type for event_type in event_types]),
+            event_types=data_source.get("event_types", event_types),
             extrapolation_mode=extrapolation_mode,
         )
 

tests/sentry/incidents/endpoints/validators/test_validators.py

@@ -1,3 +1,4 @@
+from typing import Any
 from unittest import mock
 
 import orjson
@@ -756,23 +757,26 @@ def test_create_detector_trace_metrics_valid_aggregates(self) -> None:
         )
 
 
+@mock.patch("sentry.incidents.metric_issue_detector.schedule_update_project_config")
 class TestMetricAlertsResolution(TestMetricAlertsDetectorValidator):
-    """Tests that resolution is computed correctly via get_alert_resolution."""
+    def _make_data_source(self, **overrides: Any) -> dict[str, Any]:
+        return {
+            "queryType": SnubaQuery.Type.ERROR.value,
+            "dataset": Dataset.Events.value,
+            "query": "test query",
+            "aggregate": "count()",
+            "timeWindow": 3600,
+            "environment": self.environment.name,
+            "eventTypes": [SnubaQueryEventType.EventType.ERROR.name.lower()],
+            **overrides,
+        }
 
-    @mock.patch("sentry.incidents.metric_issue_detector.schedule_update_project_config")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
     def test_create_static_small_window_uses_default_resolution(
-        self, mock_audit: mock.MagicMock, mock_schedule: mock.MagicMock
+        self, mock_schedule: mock.MagicMock
     ) -> None:
-        """A 10-minute static detector should get 1-minute resolution (default)."""
         data = {
             **self.valid_data,
-            "dataSources": [
-                {
-                    **self.valid_data["dataSources"][0],
-                    "timeWindow": 600,  # 10 minutes in seconds
-                }
-            ],
+            "dataSources": [self._make_data_source(timeWindow=600)],
         }
         validator = MetricIssueDetectorValidator(data=data, context=self.context)
         assert validator.is_valid(), validator.errors
@@ -783,20 +787,12 @@ def test_create_static_small_window_uses_default_resolution(
         expected = get_alert_resolution(10, self.project.organization).total_seconds()
         assert snuba_query.resolution == expected
 
-    @mock.patch("sentry.incidents.metric_issue_detector.schedule_update_project_config")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
     def test_create_static_large_window_uses_scaled_resolution(
-        self, mock_audit: mock.MagicMock, mock_schedule: mock.MagicMock
+        self, mock_schedule: mock.MagicMock
     ) -> None:
-        """A 60-minute static detector should get 3-minute resolution."""
         data = {
             **self.valid_data,
-            "dataSources": [
-                {
-                    **self.valid_data["dataSources"][0],
-                    "timeWindow": 3600,  # 60 minutes in seconds
-                }
-            ],
+            "dataSources": [self._make_data_source(timeWindow=3600)],
         }
         validator = MetricIssueDetectorValidator(data=data, context=self.context)
         assert validator.is_valid(), validator.errors
@@ -809,11 +805,9 @@ def test_create_static_large_window_uses_scaled_resolution(
         assert snuba_query.resolution == 180  # 3 minutes in seconds
 
     @mock.patch("sentry.seer.anomaly_detection.store_data_workflow_engine.make_store_data_request")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
     def test_create_dynamic_resolution_equals_time_window(
-        self, mock_audit: mock.MagicMock, mock_seer_request: mock.MagicMock
+        self, mock_seer_request: mock.MagicMock, mock_schedule: mock.MagicMock
     ) -> None:
-        """Dynamic detectors should use resolution == time_window."""
         seer_return_value: StoreDataResponse = {"success": True}
         mock_seer_request.return_value = HTTPResponse(orjson.dumps(seer_return_value), status=200)
 
@@ -822,20 +816,10 @@ def test_create_dynamic_resolution_equals_time_window(
         snuba_query = self.get_snuba_query(detector)
         assert snuba_query.resolution == snuba_query.time_window
 
-    @mock.patch("sentry.incidents.metric_issue_detector.schedule_update_project_config")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
-    def test_create_percent_resolution_doubled(
-        self, mock_audit: mock.MagicMock, mock_schedule: mock.MagicMock
-    ) -> None:
-        """Percent (comparison) detectors should double the resolution."""
+    def test_create_percent_resolution_doubled(self, mock_schedule: mock.MagicMock) -> None:
         data = {
             **self.valid_data,
-            "dataSources": [
-                {
-                    **self.valid_data["dataSources"][0],
-                    "timeWindow": 3600,  # 60 minutes
-                }
-            ],
+            "dataSources": [self._make_data_source(timeWindow=3600)],
             "config": {
                 "thresholdPeriod": 1,
                 "detectionType": AlertRuleDetectionType.PERCENT.value,
@@ -853,25 +837,15 @@ def test_create_percent_resolution_doubled(
         assert snuba_query.resolution == expected
         assert snuba_query.resolution == 360  # 3 min * 2 = 6 minutes in seconds
 
-    @mock.patch("sentry.incidents.metric_issue_detector.schedule_update_project_config")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
     def test_update_time_window_recalculates_resolution(
-        self, mock_audit: mock.MagicMock, mock_schedule: mock.MagicMock
+        self, mock_schedule: mock.MagicMock
     ) -> None:
-        """Changing time_window on update should recalculate resolution."""
         detector = self.create_static_detector()
         snuba_query = self.get_snuba_query(detector)
-        old_resolution = snuba_query.resolution
 
-        # Update to a larger time window (24 hours = 1440 minutes)
         update_data = {
             **self.valid_data,
-            "dataSources": [
-                {
-                    **self.valid_data["dataSources"][0],
-                    "timeWindow": 86400,  # 1440 minutes in seconds
-                }
-            ],
+            "dataSources": [self._make_data_source(timeWindow=86400)],
         }
         update_validator = MetricIssueDetectorValidator(
             instance=detector, data=update_data, context=self.context, partial=True
@@ -883,28 +857,23 @@ def test_update_time_window_recalculates_resolution(
         expected = get_alert_resolution(1440, self.project.organization).total_seconds()
         assert snuba_query.resolution == expected
         assert snuba_query.resolution == 900  # 15 minutes in seconds
-        assert snuba_query.resolution != old_resolution
 
     @mock.patch("sentry.seer.anomaly_detection.store_data_workflow_engine.make_store_data_request")
     @mock.patch("sentry.seer.anomaly_detection.delete_rule.delete_rule_in_seer")
-    @mock.patch("sentry.workflow_engine.endpoints.validators.base.detector.create_audit_entry")
     def test_update_detection_type_change_recalculates_resolution(
         self,
-        mock_audit: mock.MagicMock,
         mock_seer_delete: mock.MagicMock,
         mock_seer_store: mock.MagicMock,
+        mock_schedule: mock.MagicMock,
     ) -> None:
-        """Changing detection_type without data_sources should still recalculate resolution."""
         seer_return_value: StoreDataResponse = {"success": True}
         mock_seer_store.return_value = HTTPResponse(orjson.dumps(seer_return_value), status=200)
         mock_seer_delete.return_value = HTTPResponse(orjson.dumps(seer_return_value), status=200)
 
         detector = self.create_dynamic_detector()
         snuba_query = self.get_snuba_query(detector)
-        # Dynamic: resolution == time_window
         assert snuba_query.resolution == snuba_query.time_window
 
-        # Change to static without changing data sources
         update_data = {
             **self.valid_data,
             "config": {