feat(issues): adds backend for "resolve in upcoming release" (#70990)

this pr adds the backend needed to support "resolve in upcoming release"
to the ProjectGroupIndex endpoint. this differs from "resolve in next
release" because it no longer does the check for if there is an
immediate next release to the current release of the issue. It will
still create the `GroupResolution` object which will eventually be
cleared in `clear_expired_resolutions` but this will now be the only way
for it to be resolved, only when a new release is created.

Author: roggenkemper

src/sentry/api/helpers/group_index/update.py

@@ -225,7 +225,6 @@ def update_groups(
         )
         if user_options:
             self_assign_issue = user_options[0].value
-
     if search_fn and not group_ids:
         try:
             cursor_result, _ = search_fn(
@@ -300,6 +299,34 @@ def update_groups(
             res_type = GroupResolution.Type.in_next_release
             res_type_str = "in_next_release"
             res_status = GroupResolution.Status.pending
+        elif status_details.get("inUpcomingRelease"):
+            if len(projects) > 1:
+                return Response(
+                    {"detail": "Cannot set resolved in upcoming release for multiple projects."},
+                    status=400,
+                )
+            release = (
+                status_details.get("inUpcomingRelease")
+                or Release.objects.filter(
+                    projects=projects[0], organization_id=projects[0].organization_id
+                )
+                .extra(select={"sort": "COALESCE(date_released, date_added)"})
+                .order_by("-sort")[0]
+            )
+            activity_type = ActivityType.SET_RESOLVED_IN_RELEASE.value
+            activity_data = {"version": ""}
+
+            serialized_user = user_service.serialize_many(
+                filter=dict(user_ids=[user.id]), as_user=user
+            )
+            new_status_details = {
+                "inUpcomingRelease": True,
+            }
+            if serialized_user:
+                new_status_details["actor"] = serialized_user[0]
+            res_type = GroupResolution.Type.in_upcoming_release
+            res_type_str = "in_upcoming_release"
+            res_status = GroupResolution.Status.pending
         elif status_details.get("inRelease"):
             # TODO(jess): We could update validation to check if release
             # applies to multiple projects, but I think we agreed to punt
@@ -606,6 +633,7 @@ def update_groups(
             if res_type in (
                 GroupResolution.Type.in_next_release,
                 GroupResolution.Type.in_release,
+                GroupResolution.Type.in_upcoming_release,
             ):
                 result["activity"] = serialize(
                     Activity.objects.get_activities_for_group(

src/sentry/api/helpers/group_index/validators/status_details.py

@@ -1,12 +1,14 @@
 from rest_framework import serializers
 
+from sentry import features
 from sentry.models.release import Release
 
 from . import InCommitValidator
 
 
 class StatusDetailsValidator(serializers.Serializer):
     inNextRelease = serializers.BooleanField()
+    inUpcomingRelease = serializers.BooleanField()
     inRelease = serializers.CharField()
     inCommit = InCommitValidator(required=False)
     ignoreDuration = serializers.IntegerField()
@@ -54,3 +56,19 @@ def validate_inNextRelease(self, value: bool) -> "Release":
             raise serializers.ValidationError(
                 "No release data present in the system to form a basis for 'Next Release'"
             )
+
+    def validate_inUpcomingRelease(self, value: bool) -> "Release":
+        project = self.context["project"]
+
+        if not features.has("organizations:resolve-in-upcoming-release", project.organization):
+            raise serializers.ValidationError(
+                "Your organization does not have access to this feature."
+            )
+        try:
+            return (
+                Release.objects.filter(projects=project, organization_id=project.organization_id)
+                .extra(select={"sort": "COALESCE(date_released, date_added)"})
+                .order_by("-sort")[0]
+            )
+        except IndexError:
+            raise serializers.ValidationError("No release data present in the system.")

src/sentry/models/groupresolution.py

@@ -30,6 +30,7 @@ class GroupResolution(Model):
     class Type:
         in_release = 0
         in_next_release = 1
+        in_upcoming_release = 2
 
     class Status:
         pending = 0

src/sentry/tasks/clear_expired_resolutions.py

@@ -20,7 +20,7 @@ def clear_expired_resolutions(release_id):
     the system that any pending resolutions older than the given release can now
     be safely transitioned to resolved.
 
-    This is currently only used for ``in_next_release`` resolutions.
+    This is currently only used for ``in_next_release`` and ``in_upcoming_release`` resolutions.
     """
     try:
         release = Release.objects.get(id=release_id)
@@ -29,7 +29,9 @@ def clear_expired_resolutions(release_id):
 
     resolution_list = list(
         GroupResolution.objects.filter(
-            Q(type=GroupResolution.Type.in_next_release) | Q(type__isnull=True),
+            Q(type=GroupResolution.Type.in_next_release)
+            | Q(type__isnull=True)
+            | Q(type=GroupResolution.Type.in_upcoming_release),
             release__projects__in=[p.id for p in release.projects.all()],
             release__date_added__lt=release.date_added,
             status=GroupResolution.Status.pending,

tests/sentry/issues/endpoints/test_organization_group_index.py

@@ -5085,6 +5085,22 @@ def test_update_priority_no_change(self) -> None:
             group=group2, type=ActivityType.SET_PRIORITY.value, user_id=self.user.id
         ).exists()
 
+    def test_resolved_in_upcoming_release_multiple_projects(self) -> None:
+        project_2 = self.create_project(slug="foo")
+        group1 = self.create_group(status=GroupStatus.UNRESOLVED)
+        group2 = self.create_group(status=GroupStatus.UNRESOLVED, project=project_2)
+
+        self.login_as(user=self.user)
+        response = self.get_response(
+            qs_params={
+                "id": [group1.id, group2.id],
+                "statd": "resolved",
+                "statusDetails": {"inUpcomingRelease": True},
+            }
+        )
+
+        assert response.status_code == 400
+
 
 class GroupDeleteTest(APITestCase, SnubaTestCase):
     endpoint = "sentry-api-0-organization-group-index"

tests/snuba/api/endpoints/test_project_group_index.py

@@ -29,7 +29,7 @@
 from sentry.models.release import Release
 from sentry.silo.base import SiloMode
 from sentry.testutils.cases import APITestCase, SnubaTestCase
-from sentry.testutils.helpers import parse_link_header
+from sentry.testutils.helpers import parse_link_header, with_feature
 from sentry.testutils.helpers.datetime import before_now, iso_format
 from sentry.testutils.silo import assume_test_silo_mode
 from sentry.types.activity import ActivityType
@@ -791,6 +791,83 @@ def test_set_resolved_in_next_release_legacy(self):
         )
         assert activity.data["version"] == ""
 
+    @with_feature("organizations:resolve-in-upcoming-release")
+    def test_set_resolved_in_upcoming_release(self):
+        release = Release.objects.create(organization_id=self.project.organization_id, version="a")
+        release.add_project(self.project)
+
+        group = self.create_group(status=GroupStatus.UNRESOLVED)
+
+        self.login_as(user=self.user)
+
+        url = f"{self.path}?id={group.id}"
+        response = self.client.put(
+            url,
+            data={"status": "resolved", "statusDetails": {"inUpcomingRelease": True}},
+            format="json",
+        )
+        assert response.status_code == 200
+        assert response.data["status"] == "resolved"
+        assert response.data["statusDetails"]["inUpcomingRelease"]
+        assert response.data["statusDetails"]["actor"]["id"] == str(self.user.id)
+        assert "activity" in response.data
+
+        group = Group.objects.get(id=group.id)
+        assert group.status == GroupStatus.RESOLVED
+
+        resolution = GroupResolution.objects.get(group=group)
+        assert resolution.release == release
+        assert resolution.type == GroupResolution.Type.in_upcoming_release
+        assert resolution.status == GroupResolution.Status.pending
+        assert resolution.actor_id == self.user.id
+
+        assert GroupSubscription.objects.filter(
+            user_id=self.user.id, group=group, is_active=True
+        ).exists()
+
+        activity = Activity.objects.get(
+            group=group, type=ActivityType.SET_RESOLVED_IN_RELEASE.value
+        )
+        assert activity.data["version"] == ""
+
+    def test_upcoming_release_flag_validation(self):
+        release = Release.objects.create(organization_id=self.project.organization_id, version="a")
+        release.add_project(self.project)
+
+        group = self.create_group(status=GroupStatus.UNRESOLVED)
+
+        self.login_as(user=self.user)
+
+        url = f"{self.path}?id={group.id}"
+        response = self.client.put(
+            url,
+            data={"status": "resolved", "statusDetails": {"inUpcomingRelease": True}},
+            format="json",
+        )
+        assert response.status_code == 400
+        assert (
+            response.data["statusDetails"]["inUpcomingRelease"][0]
+            == "Your organization does not have access to this feature."
+        )
+
+    @with_feature("organizations:resolve-in-upcoming-release")
+    def test_upcoming_release_release_validation(self):
+        group = self.create_group(status=GroupStatus.UNRESOLVED)
+
+        self.login_as(user=self.user)
+
+        url = f"{self.path}?id={group.id}"
+        response = self.client.put(
+            url,
+            data={"status": "resolved", "statusDetails": {"inUpcomingRelease": True}},
+            format="json",
+        )
+        assert response.status_code == 400
+        assert (
+            response.data["statusDetails"]["inUpcomingRelease"][0]
+            == "No release data present in the system."
+        )
+
     def test_set_resolved_in_explicit_commit_unreleased(self):
         repo = self.create_repo(project=self.project, name=self.project.name)
         commit = self.create_commit(project=self.project, repo=repo)