saving my work

Author: mifu67

tests/sentry/incidents/subscription_processor/test_subscription_processor.py

@@ -0,0 +1,133 @@
+from datetime import timedelta
+from functools import cached_property
+from unittest.mock import call, patch
+
+from sentry.workflow_engine.models.data_condition import Condition, DataCondition
+from sentry.workflow_engine.types import DetectorPriorityLevel
+from tests.sentry.incidents.subscription_processor.test_subscription_processor_base import (
+    ProcessUpdateBaseClass,
+)
+
+
+class ProcessUpdateTest(ProcessUpdateBaseClass):
+    """
+    Test early return scenarios + simple cases.
+    """
+
+    # TODO: tests for early return scenarios. These will need to be added once
+    # we've decoupled the subscription processor from the alert rule model.
+
+    def test_simple(self) -> None:
+        """
+        Verify that an alert can trigger.
+        """
+        self.send_update(self.critical_threshold + 1)
+        assert self.get_detector_state(self.metric_detector) == DetectorPriorityLevel.HIGH
+
+    def test_resolve(self) -> None:
+        detector = self.metric_detector
+        self.send_update(self.critical_threshold + 1, timedelta(minutes=-2))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.HIGH
+
+        self.send_update(self.resolve_threshold - 1, timedelta(minutes=-1))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+
+    def test_resolve_percent_boundary(self) -> None:
+        detector = self.metric_detector
+        self.update_threshold(detector, DetectorPriorityLevel.HIGH, 0.5)
+        self.update_threshold(detector, DetectorPriorityLevel.OK, 0.5)
+        self.send_update(self.critical_threshold + 0.1, timedelta(minutes=-2))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.HIGH
+
+        self.send_update(self.resolve_threshold, timedelta(minutes=-1))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+
+    def test_reversed(self) -> None:
+        """
+        Test that resolutions work when the threshold is reversed.
+        """
+        detector = self.metric_detector
+        DataCondition.objects.filter(condition_group=detector.workflow_condition_group).delete()
+        self.set_up_data_conditions(detector, Condition.LESS, 100, None, 100)
+        self.send_update(self.critical_threshold - 1, timedelta(minutes=-2))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.HIGH
+
+        self.send_update(self.resolve_threshold, timedelta(minutes=-1))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+
+    def test_multiple_triggers(self) -> None:
+        detector = self.metric_detector
+        DataCondition.objects.filter(condition_group=detector.workflow_condition_group).delete()
+        self.set_up_data_conditions(detector, Condition.GREATER, 100, 50, 50)
+
+        self.send_update(self.warning_threshold + 1, timedelta(minutes=-5))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.MEDIUM
+
+        self.send_update(self.critical_threshold + 1, timedelta(minutes=-4))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.HIGH
+
+        self.send_update(self.critical_threshold - 1, timedelta(minutes=-3))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.MEDIUM
+
+        self.send_update(self.warning_threshold - 1, timedelta(minutes=-2))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+
+    def test_multiple_triggers_reversed(self) -> None:
+        detector = self.metric_detector
+        DataCondition.objects.filter(condition_group=detector.workflow_condition_group).delete()
+        self.set_up_data_conditions(detector, Condition.LESS, 50, 100, 100)
+
+        self.send_update(self.warning_threshold - 1, timedelta(minutes=-5))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.MEDIUM
+
+        self.send_update(self.critical_threshold - 1, timedelta(minutes=-4))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.HIGH
+
+        self.send_update(self.critical_threshold + 1, timedelta(minutes=-3))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.MEDIUM
+
+        self.send_update(self.warning_threshold + 1, timedelta(minutes=-2))
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+
+    # TODO: the subscription processor has a 10 minute cooldown period for creating new incidents
+    # We probably need similar logic within workflow engine.
+
+
+class ProcessUpdateComparisonAlertTest(ProcessUpdateBaseClass):
+    @cached_property
+    def comparison_detector_above(self):
+        detector = self.metric_detector
+        detector.config.update({"comparison_delta": 60 * 60})
+        self.update_threshold(detector, DetectorPriorityLevel.HIGH, 150)
+        snuba_query = self.get_snuba_query(detector)
+        snuba_query.update(time_window=60 * 60)
+        return detector
+
+    @cached_property
+    def comparison_detector_below(self):
+        detector = self.metric_detector
+        detector.config.update({"comparison_delta": 60 * 60})
+        DataCondition.objects.filter(condition_group=detector.workflow_condition_group).delete()
+        self.set_up_data_conditions(detector, Condition.LESS, 50, None, 50)
+        snuba_query = self.get_snuba_query(detector)
+        snuba_query.update(time_window=60 * 60)
+        return detector
+
+    @patch("sentry.incidents.utils.process_update_helpers.metrics")
+    def test_comparison_alert_above(self, helper_metrics):
+        detector = self.comparison_detector_above
+        # comparison_delta = timedelta(seconds=detector.config["comparison_delta"])
+        self.send_update(self.critical_threshold + 1, timedelta(minutes=-10), subscription=self.sub)
+
+        # Shouldn't trigger, since there should be no data in the comparison period
+        assert self.get_detector_state(detector) == DetectorPriorityLevel.OK
+        helper_metrics.incr.assert_has_calls(
+            [
+                call("incidents.alert_rules.skipping_update_comparison_value_invalid"),
+            ]
+        )
+        self.metrics.incr.assert_has_calls(
+            [
+                call("incidents.alert_rules.skipping_update_invalid_aggregation_value"),
+            ]
+        )

tests/sentry/incidents/subscription_processor/test_subscription_processor_base.py

@@ -18,13 +18,16 @@
 from sentry.testutils.cases import SnubaTestCase, SpanTestCase, TestCase
 from sentry.testutils.fixtures import DetectorPriorityLevel
 from sentry.testutils.helpers.datetime import freeze_time
+from sentry.testutils.helpers.features import apply_feature_flag_on_cls
+from sentry.workflow_engine.models import DataSource, DataSourceDetector, DetectorState
 from sentry.workflow_engine.models.data_condition import Condition, DataCondition
 from sentry.workflow_engine.models.detector import Detector
 
 EMPTY = object()
 
 
 @freeze_time()
+@apply_feature_flag_on_cls("organizations:workflow-engine-single-process-metric-issues")
 class ProcessUpdateBaseClass(TestCase, SpanTestCase, SnubaTestCase):
     @pytest.fixture(autouse=True)
     def _setup_metrics_patch(self):
@@ -52,6 +55,7 @@ def create_detector_data_source_and_data_conditions(self):
             type=MetricIssue.slug,
             created_by_id=self.user.id,
         )
+        self.create_detector_state(detector=detector)
         with self.tasks():
             snuba_query = create_snuba_query(
                 query_type=SnubaQuery.Type.ERROR,
@@ -138,6 +142,39 @@ def critical_threshold(self):
         )
         return critical_detector_trigger.comparison
 
+    @cached_property
+    def warning_threshold(self):
+        warning_detector_trigger = DataCondition.objects.get(
+            condition_group=self.metric_detector.workflow_condition_group,
+            condition_result=DetectorPriorityLevel.MEDIUM,
+        )
+        return warning_detector_trigger.comparison
+
+    @cached_property
+    def resolve_threshold(self):
+        resolve_detector_trigger = DataCondition.objects.get(
+            condition_group=self.metric_detector.workflow_condition_group,
+            condition_result=DetectorPriorityLevel.OK,
+        )
+        return resolve_detector_trigger.comparison
+
+    def get_snuba_query(self, detector: Detector):
+        data_source_detector = DataSourceDetector.objects.get(detector=detector)
+        data_source = DataSource.objects.get(id=data_source_detector.data_source.id)
+        query_subscription = QuerySubscription.objects.get(id=data_source.source_id)
+        snuba_query = SnubaQuery.objects.get(id=query_subscription.snuba_query.id)
+        return snuba_query
+
+    def update_threshold(
+        self, detector: Detector, priority_level: DetectorPriorityLevel, new_threshold: float
+    ) -> None:
+        detector_trigger = DataCondition.objects.get(
+            condition_group=detector.workflow_condition_group,
+            condition_result=priority_level,
+        )
+        detector_trigger.comparison = new_threshold
+        detector_trigger.save()
+
     def build_subscription_update(self, subscription, time_delta=None, value=EMPTY):
         if time_delta is not None:
             timestamp = timezone.now() + time_delta
@@ -172,3 +209,13 @@ def send_update(self, value, time_delta=None, subscription=None):
         ):
             processor.process_update(message)
         return processor
+
+    # assert active incident: assert that open period exists
+    # which means occurrence created, open period for its group, date_ended is null
+    # query for occurrence evidence_data["detector_id"] == self.detector.id?
+    # wait but we can't even filter. sigh.
+    # I guess I can check the detector status. ugh.
+    # I can also check that there's no open periods for the *project*, but idk how helpful that is
+    def get_detector_state(self, detector: Detector) -> DetectorPriorityLevel:
+        detector_state = DetectorState.objects.get(detector=detector)
+        return int(detector_state.state)