ref(slack): Clean up tests (#28846)

src/sentry/integrations/slack/endpoints/action.py

@@ -316,7 +316,6 @@ class SlackActionEndpoint(Endpoint):  # type: ignore
                     self.open_resolve_dialog(data, group, integration)
                     defer_attachment_update = True
         except client.ApiError as e:
-
             if e.status_code == 403:
                 text = UNLINK_IDENTITY_MESSAGE.format(
                     associate_url=build_unlinking_url(

tests/sentry/integrations/slack/__init__.py

@@ -0,0 +1,36 @@
+from sentry.models import (
+    Identity,
+    IdentityProvider,
+    IdentityStatus,
+    Integration,
+    Organization,
+    OrganizationIntegration,
+    User,
+)
+
+
+def install_slack(organization: Organization, workspace_id: str = "TXXXXXXX1") -> Integration:
+    integration = Integration.objects.create(
+        external_id=workspace_id,
+        metadata={
+            "access_token": "xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
+            "domain_name": "sentry.slack.com",
+            "installation_type": "born_as_bot",
+        },
+        name="Awesome Team",
+        provider="slack",
+    )
+    OrganizationIntegration.objects.create(organization=organization, integration=integration)
+    return integration
+
+
+def add_identity(
+    integration: Integration, user: User, external_id: str = "UXXXXXXX1"
+) -> IdentityProvider:
+    idp = IdentityProvider.objects.create(
+        type="slack", external_id=integration.external_id, config={}
+    )
+    Identity.objects.create(
+        user=user, idp=idp, external_id=external_id, status=IdentityStatus.VALID
+    )
+    return idp

tests/sentry/integrations/slack/test_action_endpoint.py → tests/sentry/integrations/slack/endpoints/test_action.py

@@ -1,6 +1,7 @@
 from urllib.parse import parse_qs
 
 import responses
+from freezegun import freeze_time
 
 from sentry.api import client
 from sentry.integrations.slack.endpoints.action import (
@@ -24,33 +25,15 @@ from sentry.models import (
 from sentry.testutils import APITestCase
 from sentry.utils import json
 from sentry.utils.compat.mock import patch
+from tests.sentry.integrations.slack import add_identity, install_slack
 
 
 class BaseEventTest(APITestCase):
     def setUp(self):
         super().setUp()
-        self.user = self.create_user(is_superuser=False)
-        self.org = self.create_organization(owner=None)
-        self.team = self.create_team(organization=self.org, members=[self.user])
-
-        self.integration = Integration.objects.create(
-            provider="slack",
-            external_id="TXXXXXXX1",
-            metadata={"access_token": "xoxa-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"},
-        )
-        OrganizationIntegration.objects.create(organization=self.org, integration=self.integration)
-
-        self.idp = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX1", config={})
-        self.identity = Identity.objects.create(
-            external_id="slack_id",
-            idp=self.idp,
-            user=self.user,
-            status=IdentityStatus.VALID,
-            scopes=[],
-        )
-
-        self.project1 = self.create_project(organization=self.org)
-        self.group1 = self.create_group(project=self.project1)
+        self.external_id = "slack:1"
+        self.integration = install_slack(self.organization)
+        self.idp = add_identity(self.integration, self.user, self.external_id)
 
         self.trigger_id = "13345224609.738474920.8088930838d88f008e0"
         self.response_url = (
@@ -73,10 +56,10 @@ class BaseEventTest(APITestCase):
     ):
 
         if slack_user is None:
-            slack_user = {"id": self.identity.external_id, "domain": "example"}
+            slack_user = {"id": self.external_id, "domain": "example"}
 
         if callback_id is None:
-            callback_id = json.dumps({"issue": self.group1.id})
+            callback_id = json.dumps({"issue": self.group.id})
 
         if original_message is None:
             original_message = {}
@@ -104,15 +87,14 @@ class BaseEventTest(APITestCase):
 
 
 class StatusActionTest(BaseEventTest):
-    @patch("sentry.integrations.slack.views.sign")
-    def test_ask_linking(self, sign):
-        """Patching out `sign` to prevent flakiness from timestamp mismatch."""
-        sign.return_value = "signed_parameters"
+    @freeze_time("2021-01-14T12:27:28.303Z")
+    def test_ask_linking(self):
+        """Freezing time to prevent flakiness from timestamp mismatch."""
 
         resp = self.post_webhook(slack_user={"id": "invalid-id", "domain": "example"})
 
         associate_url = build_linking_url(
-            self.integration, self.org, "invalid-id", "C065W1189", self.response_url
+            self.integration, self.organization, "invalid-id", "C065W1189", self.response_url
         )
 
         assert resp.status_code == 200, resp.content
@@ -123,35 +105,35 @@ class StatusActionTest(BaseEventTest):
         status_action = {"name": "status", "value": "ignored", "type": "button"}
 
         resp = self.post_webhook(action_data=[status_action])
-        self.group1 = Group.objects.get(id=self.group1.id)
+        self.group = Group.objects.get(id=self.group.id)
 
         assert resp.status_code == 200, resp.content
-        assert self.group1.get_status() == GroupStatus.IGNORED
+        assert self.group.get_status() == GroupStatus.IGNORED
 
-        expect_status = f"*Issue ignored by <@{self.identity.external_id}>*"
+        expect_status = f"*Issue ignored by <@{self.external_id}>*"
         assert resp.data["text"].endswith(expect_status), resp.data["text"]
 
     def test_ignore_issue_with_additional_user_auth(self):
         """
         Ensure that we can act as a user even when the organization has SSO enabled
         """
-        auth_idp = AuthProvider.objects.create(organization=self.org, provider="dummy")
+        auth_idp = AuthProvider.objects.create(organization=self.organization, provider="dummy")
         AuthIdentity.objects.create(auth_provider=auth_idp, user=self.user)
 
         status_action = {"name": "status", "value": "ignored", "type": "button"}
 
         resp = self.post_webhook(action_data=[status_action])
-        self.group1 = Group.objects.get(id=self.group1.id)
+        self.group = Group.objects.get(id=self.group.id)
 
         assert resp.status_code == 200, resp.content
-        assert self.group1.get_status() == GroupStatus.IGNORED
+        assert self.group.get_status() == GroupStatus.IGNORED
 
-        expect_status = f"*Issue ignored by <@{self.identity.external_id}>*"
+        expect_status = f"*Issue ignored by <@{self.external_id}>*"
         assert resp.data["text"].endswith(expect_status), resp.data["text"]
 
     def test_assign_issue(self):
         user2 = self.create_user(is_superuser=False)
-        self.create_member(user=user2, organization=self.org, teams=[self.team])
+        self.create_member(user=user2, organization=self.organization, teams=[self.team])
 
         # Assign to user
         status_action = {
@@ -162,11 +144,9 @@ class StatusActionTest(BaseEventTest):
         resp = self.post_webhook(action_data=[status_action])
 
         assert resp.status_code == 200, resp.content
-        assert GroupAssignee.objects.filter(group=self.group1, user=user2).exists()
+        assert GroupAssignee.objects.filter(group=self.group, user=user2).exists()
 
-        expect_status = (
-            f"*Issue assigned to {user2.get_display_name()} by <@{self.identity.external_id}>*"
-        )
+        expect_status = f"*Issue assigned to {user2.get_display_name()} by <@{self.external_id}>*"
 
         # Assign to team
         status_action = {
@@ -177,15 +157,15 @@ class StatusActionTest(BaseEventTest):
         resp = self.post_webhook(action_data=[status_action])
 
         assert resp.status_code == 200, resp.content
-        assert GroupAssignee.objects.filter(group=self.group1, team=self.team).exists()
+        assert GroupAssignee.objects.filter(group=self.group, team=self.team).exists()
 
-        expect_status = f"*Issue assigned to #{self.team.slug} by <@{self.identity.external_id}>*"
+        expect_status = f"*Issue assigned to #{self.team.slug} by <@{self.external_id}>*"
 
         assert resp.data["text"].endswith(expect_status), resp.data["text"]
 
     def test_assign_issue_user_has_identity(self):
         user2 = self.create_user(is_superuser=False)
-        self.create_member(user=user2, organization=self.org, teams=[self.team])
+        self.create_member(user=user2, organization=self.organization, teams=[self.team])
 
         user2_identity = Identity.objects.create(
             external_id="slack_id2",
@@ -203,10 +183,10 @@ class StatusActionTest(BaseEventTest):
         resp = self.post_webhook(action_data=[status_action])
 
         assert resp.status_code == 200, resp.content
-        assert GroupAssignee.objects.filter(group=self.group1, user=user2).exists()
+        assert GroupAssignee.objects.filter(group=self.group, user=user2).exists()
 
         expect_status = (
-            f"*Issue assigned to <@{user2_identity.external_id}> by <@{self.identity.external_id}>*"
+            f"*Issue assigned to <@{user2_identity.external_id}> by <@{self.external_id}>*"
         )
 
         assert resp.data["text"].endswith(expect_status), resp.data["text"]
@@ -217,11 +197,11 @@ class StatusActionTest(BaseEventTest):
         original_message = {"type": "message"}
 
         resp = self.post_webhook(action_data=[status_action], original_message=original_message)
-        self.group1 = Group.objects.get(id=self.group1.id)
+        self.group = Group.objects.get(id=self.group.id)
 
         assert resp.status_code == 200, resp.content
         assert "attachments" in resp.data
-        assert resp.data["attachments"][0]["title"] == self.group1.title
+        assert resp.data["attachments"][0]["title"] == self.group.title
 
     def test_assign_user_with_multiple_identities(self):
         org2 = self.create_organization(owner=None)
@@ -250,10 +230,10 @@ class StatusActionTest(BaseEventTest):
         resp = self.post_webhook(action_data=[status_action])
 
         assert resp.status_code == 200, resp.content
-        assert GroupAssignee.objects.filter(group=self.group1, user=self.user).exists()
+        assert GroupAssignee.objects.filter(group=self.group, user=self.user).exists()
 
         expect_status = "*Issue assigned to <@{assignee}> by <@{assignee}>*".format(
-            assignee=self.identity.external_id
+            assignee=self.external_id
         )
 
         assert resp.data["text"].endswith(expect_status), resp.data["text"]
@@ -284,7 +264,7 @@ class StatusActionTest(BaseEventTest):
 
         dialog = json.loads(data["dialog"][0])
         callback_data = json.loads(dialog["callback_id"])
-        assert int(callback_data["issue"]) == self.group1.id
+        assert int(callback_data["issue"]) == self.group.id
         assert callback_data["orig_response_url"] == self.response_url
 
         # Completing the dialog will update the message
@@ -301,14 +281,14 @@ class StatusActionTest(BaseEventTest):
             callback_id=dialog["callback_id"],
             data={"submission": {"resolve_type": "resolved"}},
         )
-        self.group1 = Group.objects.get(id=self.group1.id)
+        self.group = Group.objects.get(id=self.group.id)
 
         assert resp.status_code == 200, resp.content
-        assert self.group1.get_status() == GroupStatus.RESOLVED
+        assert self.group.get_status() == GroupStatus.RESOLVED
 
         update_data = json.loads(responses.calls[1].request.body)
 
-        expect_status = f"*Issue resolved by <@{self.identity.external_id}>*"
+        expect_status = f"*Issue resolved by <@{self.external_id}>*"
         assert update_data["text"].endswith(expect_status)
 
     def test_permission_denied(self):
@@ -327,19 +307,20 @@ class StatusActionTest(BaseEventTest):
         resp = self.post_webhook(
             action_data=[status_action], slack_user={"id": user2_identity.external_id}
         )
-        self.group1 = Group.objects.get(id=self.group1.id)
+        self.group = Group.objects.get(id=self.group.id)
 
         associate_url = build_unlinking_url(
-            self.integration.id, self.org.id, "slack_id2", "C065W1189", self.response_url
+            self.integration.id, self.organization.id, "slack_id2", "C065W1189", self.response_url
         )
 
         assert resp.status_code == 200, resp.content
         assert resp.data["response_type"] == "ephemeral"
         assert not resp.data["replace_original"]
         assert resp.data["text"] == UNLINK_IDENTITY_MESSAGE.format(
-            associate_url=associate_url, user_email=user2.email, org_name=self.org.name
+            associate_url=associate_url, user_email=user2.email, org_name=self.organization.name
         )
 
+    @freeze_time("2021-01-14T12:27:28.303Z")
     @responses.activate
     @patch("sentry.api.client.put")
     def test_handle_submission_fail(self, client_put):
@@ -367,7 +348,7 @@ class StatusActionTest(BaseEventTest):
 
         dialog = json.loads(data["dialog"][0])
         callback_data = json.loads(dialog["callback_id"])
-        assert int(callback_data["issue"]) == self.group1.id
+        assert int(callback_data["issue"]) == self.group.id
         assert callback_data["orig_response_url"] == self.response_url
 
         # Completing the dialog will update the message
@@ -390,15 +371,20 @@ class StatusActionTest(BaseEventTest):
             data={"submission": {"resolve_type": "resolved"}},
         )
 
-        client_put.asser_called()
+        # TODO(mgaeta): `assert_called` is deprecated. Find a replacement.
+        # client_put.assert_called()
 
         associate_url = build_unlinking_url(
-            self.integration.id, self.org.id, "slack_id", "C065W1189", self.response_url
+            self.integration.id,
+            self.organization.id,
+            self.external_id,
+            "C065W1189",
+            self.response_url,
         )
 
         assert resp.status_code == 200, resp.content
         assert resp.data["text"] == UNLINK_IDENTITY_MESSAGE.format(
-            associate_url=associate_url, user_email=self.user.email, org_name=self.org.name
+            associate_url=associate_url, user_email=self.user.email, org_name=self.organization.name
         )
 
     @patch(
@@ -422,7 +408,7 @@ class StatusActionTest(BaseEventTest):
     def test_sentry_docs_link_clicked(self, check_signing_secret_mock):
         payload = {
             "team": {"id": "TXXXXXXX1", "domain": "example.com"},
-            "user": {"id": self.identity.external_id, "domain": "example"},
+            "user": {"id": self.external_id, "domain": "example"},
             "type": "block_actions",
             "actions": [{"value": "sentry_docs_link_clicked"}],
         }

tests/sentry/api/endpoints/test_integrations_slack_commands.py → tests/sentry/integrations/slack/endpoints/test_commands.py

@@ -30,13 +30,13 @@ from sentry.models import (
     Identity,
     IdentityProvider,
     IdentityStatus,
-    Integration,
     NotificationSetting,
 )
 from sentry.notifications.types import NotificationScopeType
 from sentry.testutils import APITestCase, TestCase
 from sentry.types.integrations import ExternalProviders
 from sentry.utils import json
+from tests.sentry.integrations.slack import install_slack
 
 
 def get_response_text(data: SlackBody) -> str:
@@ -123,16 +123,7 @@ class SlackCommandsTest(APITestCase, TestCase):
     def setUp(self):
         super().setUp()
         self.external_id = "slack:1"
-        self.integration = Integration.objects.create(
-            provider="slack",
-            name="Slack",
-            external_id=self.external_id,
-            metadata={
-                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
-                "installation_type": "born_as_bot",
-            },
-        )
-        self.integration.add_organization(self.organization, self.user)
+        self.integration = install_slack(self.organization, self.external_id)
         self.idp = IdentityProvider.objects.create(type="slack", external_id="slack:1", config={})
         self.login_as(self.user)
 
@@ -307,7 +298,10 @@ class SlackCommandsLinkTeamTest(SlackCommandsTest):
         assert len(team_settings) == 1
 
     def test_link_another_team_to_channel(self):
-        """Test that we block a user who tries to link a second team to a channel that already has a team linked to it."""
+        """
+        Test that we block a user who tries to link a second team to a
+        channel that already has a team linked to it.
+        """
         ExternalActor.objects.create(
             actor_id=self.team.actor_id,
             organization=self.organization,
@@ -330,7 +324,10 @@ class SlackCommandsLinkTeamTest(SlackCommandsTest):
         assert CHANNEL_ALREADY_LINKED_MESSAGE in data["text"]
 
     def test_link_team_from_dm(self):
-        """Test that if a user types /sentry link team from a DM instead of a channel, we reply with an error message."""
+        """
+        Test that if a user types `/sentry link team` from a DM instead of a
+        channel, we reply with an error message.
+        """
         response = self.get_slack_response(
             {
                 "text": "link team",
@@ -354,8 +351,10 @@ class SlackCommandsLinkTeamTest(SlackCommandsTest):
 
     @responses.activate
     def test_link_team_insufficient_role(self):
-        """Test that when a user whose role is insufficient attempts to link a team, we reject
-        them and reply with the INSUFFICIENT_ROLE_MESSAGE"""
+        """
+        Test that when a user whose role is insufficient attempts to link a
+        team, we reject them and reply with the INSUFFICIENT_ROLE_MESSAGE.
+        """
         user2 = self.create_user()
         self.create_member(
             teams=[self.team], user=user2, role="member", organization=self.organization
@@ -491,7 +490,10 @@ class SlackCommandsUnlinkTeamTest(SlackCommandsTest):
         assert len(team_settings) == 0
 
     def test_unlink_no_team(self):
-        """Test for when a user attempts to remove a link between a Slack channel and a Sentry team that does not exist"""
+        """
+        Test for when a user attempts to remove a link between a Slack channel
+        and a Sentry team that does not exist.
+        """
         data = self.send_slack_message(
             "unlink team",
             channel_name="specific",
@@ -501,8 +503,12 @@ class SlackCommandsUnlinkTeamTest(SlackCommandsTest):
 
     @responses.activate
     def test_unlink_multiple_teams(self):
-        """Test that if you have linked multiple teams to a single channel, when you type /sentry unlink team,
-        we unlink all teams from that channel. This should only apply to one org who did this before we blocked users from doing so."""
+        """
+        Test that if you have linked multiple teams to a single channel, when
+        you type `/sentry unlink team`, we unlink all teams from that channel.
+        This should only apply to the one organization who did this before we
+        blocked users from doing so.
+        """
         team2 = self.create_team(organization=self.organization, name="Team Hellboy")
         ExternalActor.objects.create(
             actor_id=team2.actor_id,

tests/sentry/integrations/slack/test_event_endpoint.py → tests/sentry/integrations/slack/endpoints/test_event.py

@@ -4,16 +4,11 @@ from urllib.parse import parse_qsl
 import responses
 
 from sentry.integrations.slack.unfurl import Handler, LinkType, make_type_coercer
-from sentry.models import (
-    Identity,
-    IdentityProvider,
-    IdentityStatus,
-    Integration,
-    OrganizationIntegration,
-)
+from sentry.models import Identity, IdentityProvider, IdentityStatus
 from sentry.testutils import APITestCase
 from sentry.utils import json
 from sentry.utils.compat.mock import Mock, patch
+from tests.sentry.integrations.slack import install_slack
 
 UNSET = object()
 
@@ -83,14 +78,7 @@ MESSAGE_IM_BOT_EVENT = """{
 class BaseEventTest(APITestCase):
     def setUp(self):
         super().setUp()
-        self.user = self.create_user(is_superuser=False)
-        self.org = self.create_organization(owner=None)
-        self.integration = Integration.objects.create(
-            provider="slack",
-            external_id="TXXXXXXX1",
-            metadata={"access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"},
-        )
-        OrganizationIntegration.objects.create(organization=self.org, integration=self.integration)
+        self.integration = install_slack(self.organization)
 
     @patch(
         "sentry.integrations.slack.requests.SlackRequest._check_signing_secret", return_value=True
@@ -179,7 +167,7 @@ class LinkSharedEventTest(BaseEventTest):
 
     def test_valid_token(self):
         data = self.share_links()
-        assert data["token"] == "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert data["token"] == "xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
 
     def test_user_access_token(self):
         # this test is needed to make sure that classic bots installed by on-prem users
@@ -278,7 +266,7 @@ class MessageIMEventTest(BaseEventTest):
         resp = self.post_webhook(event_data=json.loads(MESSAGE_IM_EVENT))
         assert resp.status_code == 200, resp.content
         request = responses.calls[0].request
-        assert request.headers["Authorization"] == "Bearer xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert request.headers["Authorization"] == "Bearer xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
         data = json.loads(request.body)
         heading, contents = self.get_block_section_text(data)
         assert heading == "Unknown command: `helloo`"
@@ -298,7 +286,7 @@ class MessageIMEventTest(BaseEventTest):
         resp = self.post_webhook(event_data=json.loads(MESSAGE_IM_EVENT_LINK))
         assert resp.status_code == 200, resp.content
         request = responses.calls[0].request
-        assert request.headers["Authorization"] == "Bearer xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert request.headers["Authorization"] == "Bearer xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
         data = json.loads(request.body)
         assert "Link your Slack identity" in data["text"]
 
@@ -320,7 +308,7 @@ class MessageIMEventTest(BaseEventTest):
         resp = self.post_webhook(event_data=json.loads(MESSAGE_IM_EVENT_LINK))
         assert resp.status_code == 200, resp.content
         request = responses.calls[0].request
-        assert request.headers["Authorization"] == "Bearer xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert request.headers["Authorization"] == "Bearer xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
         data = json.loads(request.body)
         assert "You are already linked" in data["text"]
 
@@ -342,7 +330,7 @@ class MessageIMEventTest(BaseEventTest):
         resp = self.post_webhook(event_data=json.loads(MESSAGE_IM_EVENT_UNLINK))
         assert resp.status_code == 200, resp.content
         request = responses.calls[0].request
-        assert request.headers["Authorization"] == "Bearer xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert request.headers["Authorization"] == "Bearer xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
         data = json.loads(request.body)
         assert "Click here to unlink your identity" in data["text"]
 
@@ -357,7 +345,7 @@ class MessageIMEventTest(BaseEventTest):
         resp = self.post_webhook(event_data=json.loads(MESSAGE_IM_EVENT_UNLINK))
         assert resp.status_code == 200, resp.content
         request = responses.calls[0].request
-        assert request.headers["Authorization"] == "Bearer xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
+        assert request.headers["Authorization"] == "Bearer xoxb-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"
         data = json.loads(request.body)
         assert "You do not have a linked identity to unlink" in data["text"]
 

tests/sentry/integrations/slack/notifications/__init__.py

@@ -0,0 +1,80 @@
+from urllib.parse import parse_qs
+
+import responses
+from exam import fixture
+
+from sentry.integrations.slack.notifications import send_notification_as_slack
+from sentry.mail import mail_adapter
+from sentry.models import (
+    Identity,
+    IdentityProvider,
+    IdentityStatus,
+    NotificationSetting,
+    UserOption,
+)
+from sentry.notifications.types import NotificationSettingOptionValues, NotificationSettingTypes
+from sentry.types.integrations import ExternalProviders
+from sentry.utils import json
+from tests.sentry.integrations.slack import install_slack
+from tests.sentry.mail.activity import ActivityTestCase
+
+
+def send_notification(*args):
+    args_list = list(args)[1:]
+    send_notification_as_slack(*args_list, {})
+
+
+def get_attachment():
+    assert len(responses.calls) >= 1
+    data = parse_qs(responses.calls[0].request.body)
+    assert "text" in data
+    assert "attachments" in data
+    attachments = json.loads(data["attachments"][0])
+
+    assert len(attachments) == 1
+    return attachments[0], data["text"][0]
+
+
+class SlackActivityNotificationTest(ActivityTestCase):
+    @fixture
+    def adapter(self):
+        return mail_adapter
+
+    def setUp(self):
+        NotificationSetting.objects.update_settings(
+            ExternalProviders.SLACK,
+            NotificationSettingTypes.WORKFLOW,
+            NotificationSettingOptionValues.ALWAYS,
+            user=self.user,
+        )
+        NotificationSetting.objects.update_settings(
+            ExternalProviders.SLACK,
+            NotificationSettingTypes.DEPLOY,
+            NotificationSettingOptionValues.ALWAYS,
+            user=self.user,
+        )
+        NotificationSetting.objects.update_settings(
+            ExternalProviders.SLACK,
+            NotificationSettingTypes.ISSUE_ALERTS,
+            NotificationSettingOptionValues.ALWAYS,
+            user=self.user,
+        )
+        UserOption.objects.create(user=self.user, key="self_notifications", value="1")
+        self.integration = install_slack(self.organization)
+        self.idp = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX1", config={})
+        self.identity = Identity.objects.create(
+            external_id="UXXXXXXX1",
+            idp=self.idp,
+            user=self.user,
+            status=IdentityStatus.VALID,
+            scopes=[],
+        )
+        responses.add(
+            method=responses.POST,
+            url="https://slack.com/api/chat.postMessage",
+            body='{"ok": true}',
+            status=200,
+            content_type="application/json",
+        )
+        self.name = self.user.get_display_name()
+        self.short_id = self.group.qualified_short_id

tests/sentry/integrations/slack/notifications/test_assigned.py

@@ -0,0 +1,146 @@
+from urllib.parse import parse_qs
+
+import responses
+
+from sentry.models import Activity, Identity, IdentityProvider, IdentityStatus, Integration
+from sentry.notifications.notifications.activity import AssignedActivityNotification
+from sentry.types.activity import ActivityType
+from sentry.utils.compat import mock
+
+from . import SlackActivityNotificationTest, get_attachment, send_notification
+
+
+class SlackAssignedNotificationTest(SlackActivityNotificationTest):
+    @responses.activate
+    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
+    def test_multiple_identities(self, mock_func):
+        """
+        Test that we notify a user with multiple Identities in each place
+        """
+        integration2 = Integration.objects.create(
+            provider="slack",
+            name="Team B",
+            external_id="TXXXXXXX2",
+            metadata={
+                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
+                "installation_type": "born_as_bot",
+            },
+        )
+        integration2.add_organization(self.organization, self.user)
+        idp2 = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX2", config={})
+        identity2 = Identity.objects.create(
+            external_id="UXXXXXXX2",
+            idp=idp2,
+            user=self.user,
+            status=IdentityStatus.VALID,
+            scopes=[],
+        )
+        # create a second response
+        responses.add(
+            method=responses.POST,
+            url="https://slack.com/api/chat.postMessage",
+            body='{"ok": true}',
+            status=200,
+            content_type="application/json",
+        )
+
+        notification = AssignedActivityNotification(
+            Activity(
+                project=self.project,
+                group=self.group,
+                user=self.user,
+                type=ActivityType.ASSIGNED,
+                data={"assignee": self.user.id},
+            )
+        )
+        with self.tasks():
+            notification.send()
+
+        assert len(responses.calls) >= 2
+        data = parse_qs(responses.calls[0].request.body)
+        assert "channel" in data
+        channel = data["channel"][0]
+        assert channel == self.identity.external_id
+
+        data = parse_qs(responses.calls[1].request.body)
+        assert "channel" in data
+        channel = data["channel"][0]
+        assert channel == identity2.external_id
+
+    @responses.activate
+    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
+    def test_multiple_orgs(self, mock_func):
+        """
+        Test that if a user is in 2 orgs with Slack and has an Identity linked in each,
+        we're only going to notify them for the relevant org
+        """
+        org2 = self.create_organization(owner=self.user)
+        integration2 = Integration.objects.create(
+            provider="slack",
+            name="Team B",
+            external_id="TXXXXXXX2",
+            metadata={
+                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
+                "installation_type": "born_as_bot",
+            },
+        )
+        integration2.add_organization(org2, self.user)
+        idp2 = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX2", config={})
+        Identity.objects.create(
+            external_id="UXXXXXXX2",
+            idp=idp2,
+            user=self.user,
+            status=IdentityStatus.VALID,
+            scopes=[],
+        )
+        # create a second response that won't actually be used, but here to make sure it's not a false positive
+        responses.add(
+            method=responses.POST,
+            url="https://slack.com/api/chat.postMessage",
+            body='{"ok": true}',
+            status=200,
+            content_type="application/json",
+        )
+
+        notification = AssignedActivityNotification(
+            Activity(
+                project=self.project,
+                group=self.group,
+                user=self.user,
+                type=ActivityType.ASSIGNED,
+                data={"assignee": self.user.id},
+            )
+        )
+        with self.tasks():
+            notification.send()
+
+        assert len(responses.calls) == 1
+        data = parse_qs(responses.calls[0].request.body)
+        assert "channel" in data
+        channel = data["channel"][0]
+        assert channel == self.identity.external_id
+
+    @responses.activate
+    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
+    def test_assignment(self, mock_func):
+        """
+        Test that a Slack message is sent with the expected payload when an issue is assigned
+        """
+        notification = AssignedActivityNotification(
+            Activity(
+                project=self.project,
+                group=self.group,
+                user=self.user,
+                type=ActivityType.ASSIGNED,
+                data={"assignee": self.user.id},
+            )
+        )
+        with self.tasks():
+            notification.send()
+        attachment, text = get_attachment()
+        assert text == f"Issue assigned to {self.name} by themselves"
+        assert attachment["title"] == self.group.title
+        assert (
+            attachment["footer"]
+            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=AssignedActivitySlack|Notification Settings>"
+        )

tests/sentry/integrations/slack/notifications/test_deploy.py

@@ -0,0 +1,60 @@
+import responses
+from django.utils import timezone
+
+from sentry.models import Activity, Deploy, Release
+from sentry.notifications.notifications.activity import ReleaseActivityNotification
+from sentry.utils.compat import mock
+
+from . import SlackActivityNotificationTest, get_attachment, send_notification
+
+
+class SlackUnassignedNotificationTest(SlackActivityNotificationTest):
+    @responses.activate
+    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
+    def test_deploy(self, mock_func):
+        """
+        Test that a Slack message is sent with the expected payload when a deploy happens
+        """
+        release = Release.objects.create(
+            version="meow" * 10,
+            organization_id=self.project.organization_id,
+            date_released=timezone.now(),
+        )
+        project2 = self.create_project(name="battlesnake")
+        release.add_project(self.project)
+        release.add_project(project2)
+        deploy = Deploy.objects.create(
+            release=release,
+            organization_id=self.organization.id,
+            environment_id=self.environment.id,
+        )
+        notification = ReleaseActivityNotification(
+            Activity(
+                project=self.project,
+                user=self.user,
+                type=Activity.RELEASE,
+                data={"version": release.version, "deploy_id": deploy.id},
+            )
+        )
+        with self.tasks():
+            notification.send()
+
+        attachment, text = get_attachment()
+        assert (
+            text
+            == f"Release {release.version} was deployed to {self.environment.name} for these projects"
+        )
+        assert attachment["actions"][0]["text"] == self.project.slug
+        assert (
+            attachment["actions"][0]["url"]
+            == f"http://testserver/organizations/{self.organization.slug}/releases/{release.version}/?project={self.project.id}&unselectedSeries=Healthy/"
+        )
+        assert attachment["actions"][1]["text"] == project2.slug
+        assert (
+            attachment["actions"][1]["url"]
+            == f"http://testserver/organizations/{self.organization.slug}/releases/{release.version}/?project={project2.id}&unselectedSeries=Healthy/"
+        )
+        assert (
+            attachment["footer"]
+            == f"{self.project.slug} | <http://testserver/settings/account/notifications/deploy/?referrer=ReleaseActivitySlack|Notification Settings>"
+        )

tests/sentry/integrations/slack/test_notifications.py → tests/sentry/integrations/slack/notifications/test_issue_alert.py

@@ -1,37 +1,18 @@
 from urllib.parse import parse_qs
 
 import responses
-from django.utils import timezone
-from exam import fixture
 
 import sentry
 from sentry.digests.backends.redis import RedisBackend
 from sentry.digests.notifications import event_to_record
-from sentry.integrations.slack.notifications import send_notification_as_slack
-from sentry.mail import mail_adapter
 from sentry.models import (
-    Activity,
-    Deploy,
     ExternalActor,
     Identity,
     IdentityProvider,
     IdentityStatus,
-    Integration,
     NotificationSetting,
     ProjectOwnership,
-    Release,
     Rule,
-    UserOption,
-)
-from sentry.notifications.notifications.activity import (
-    AssignedActivityNotification,
-    NewProcessingIssuesActivityNotification,
-    NoteActivityNotification,
-    RegressionActivityNotification,
-    ReleaseActivityNotification,
-    ResolvedActivityNotification,
-    ResolvedInReleaseActivityNotification,
-    UnassignedActivityNotification,
 )
 from sentry.notifications.notifications.rules import AlertRuleNotification
 from sentry.notifications.types import (
@@ -44,461 +25,15 @@ from sentry.ownership.grammar import Rule as GrammarRule
 from sentry.ownership.grammar import dump_schema
 from sentry.plugins.base import Notification
 from sentry.tasks.digests import deliver_digest
-from sentry.testutils import TestCase
-from sentry.types.activity import ActivityType
 from sentry.types.integrations import ExternalProviders
 from sentry.utils import json
 from sentry.utils.compat import mock
 from sentry.utils.compat.mock import patch
-from tests.sentry.mail.activity import ActivityTestCase
-
-
-def send_notification(*args):
-    args_list = list(args)[1:]
-    send_notification_as_slack(*args_list, {})
-
-
-def get_attachment():
-    assert len(responses.calls) >= 1
-    data = parse_qs(responses.calls[0].request.body)
-    assert "text" in data
-    assert "attachments" in data
-    attachments = json.loads(data["attachments"][0])
-
-    assert len(attachments) == 1
-    return attachments[0], data["text"][0]
-
-
-class SlackActivityNotificationTest(ActivityTestCase, TestCase):
-    @fixture
-    def adapter(self):
-        return mail_adapter
-
-    def setUp(self):
-        NotificationSetting.objects.update_settings(
-            ExternalProviders.SLACK,
-            NotificationSettingTypes.WORKFLOW,
-            NotificationSettingOptionValues.ALWAYS,
-            user=self.user,
-        )
-        NotificationSetting.objects.update_settings(
-            ExternalProviders.SLACK,
-            NotificationSettingTypes.DEPLOY,
-            NotificationSettingOptionValues.ALWAYS,
-            user=self.user,
-        )
-        NotificationSetting.objects.update_settings(
-            ExternalProviders.SLACK,
-            NotificationSettingTypes.ISSUE_ALERTS,
-            NotificationSettingOptionValues.ALWAYS,
-            user=self.user,
-        )
-        UserOption.objects.create(user=self.user, key="self_notifications", value="1")
-        self.integration = Integration.objects.create(
-            provider="slack",
-            name="Team A",
-            external_id="TXXXXXXX1",
-            metadata={
-                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
-                "installation_type": "born_as_bot",
-            },
-        )
-        self.integration.add_organization(self.organization, self.user)
-        self.idp = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX1", config={})
-        self.identity = Identity.objects.create(
-            external_id="UXXXXXXX1",
-            idp=self.idp,
-            user=self.user,
-            status=IdentityStatus.VALID,
-            scopes=[],
-        )
-        responses.add(
-            method=responses.POST,
-            url="https://slack.com/api/chat.postMessage",
-            body='{"ok": true}',
-            status=200,
-            content_type="application/json",
-        )
-        self.name = self.user.get_display_name()
-        self.short_id = self.group.qualified_short_id
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_multiple_identities(self, mock_func):
-        """
-        Test that we notify a user with multiple Identities in each place
-        """
-        integration2 = Integration.objects.create(
-            provider="slack",
-            name="Team B",
-            external_id="TXXXXXXX2",
-            metadata={
-                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
-                "installation_type": "born_as_bot",
-            },
-        )
-        integration2.add_organization(self.organization, self.user)
-        idp2 = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX2", config={})
-        identity2 = Identity.objects.create(
-            external_id="UXXXXXXX2",
-            idp=idp2,
-            user=self.user,
-            status=IdentityStatus.VALID,
-            scopes=[],
-        )
-        # create a second response
-        responses.add(
-            method=responses.POST,
-            url="https://slack.com/api/chat.postMessage",
-            body='{"ok": true}',
-            status=200,
-            content_type="application/json",
-        )
-
-        notification = AssignedActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.ASSIGNED,
-                data={"assignee": self.user.id},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        assert len(responses.calls) >= 2
-        data = parse_qs(responses.calls[0].request.body)
-        assert "channel" in data
-        channel = data["channel"][0]
-        assert channel == self.identity.external_id
 
-        data = parse_qs(responses.calls[1].request.body)
-        assert "channel" in data
-        channel = data["channel"][0]
-        assert channel == identity2.external_id
+from . import SlackActivityNotificationTest, get_attachment, send_notification
 
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_multiple_orgs(self, mock_func):
-        """
-        Test that if a user is in 2 orgs with Slack and has an Identity linked in each,
-        we're only going to notify them for the relevant org
-        """
-        org2 = self.create_organization(owner=self.user)
-        integration2 = Integration.objects.create(
-            provider="slack",
-            name="Team B",
-            external_id="TXXXXXXX2",
-            metadata={
-                "access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx",
-                "installation_type": "born_as_bot",
-            },
-        )
-        integration2.add_organization(org2, self.user)
-        idp2 = IdentityProvider.objects.create(type="slack", external_id="TXXXXXXX2", config={})
-        Identity.objects.create(
-            external_id="UXXXXXXX2",
-            idp=idp2,
-            user=self.user,
-            status=IdentityStatus.VALID,
-            scopes=[],
-        )
-        # create a second response that won't actually be used, but here to make sure it's not a false positive
-        responses.add(
-            method=responses.POST,
-            url="https://slack.com/api/chat.postMessage",
-            body='{"ok": true}',
-            status=200,
-            content_type="application/json",
-        )
-
-        notification = AssignedActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.ASSIGNED,
-                data={"assignee": self.user.id},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        assert len(responses.calls) == 1
-        data = parse_qs(responses.calls[0].request.body)
-        assert "channel" in data
-        channel = data["channel"][0]
-        assert channel == self.identity.external_id
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_assignment(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue is assigned
-        """
-        notification = AssignedActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.ASSIGNED,
-                data={"assignee": self.user.id},
-            )
-        )
-        with self.tasks():
-            notification.send()
-        attachment, text = get_attachment()
-        assert text == f"Issue assigned to {self.name} by themselves"
-        assert attachment["title"] == self.group.title
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=AssignedActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_unassignment(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue is unassigned
-        """
-        notification = UnassignedActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.ASSIGNED,
-                data={"assignee": ""},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        assert text == f"Issue unassigned by {self.name}"
-        assert attachment["title"] == self.group.title
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=UnassignedActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_resolved(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue is resolved
-        """
-        notification = ResolvedActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.SET_RESOLVED,
-                data={"assignee": ""},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        assert (
-            text
-            == f"{self.name} marked <http://testserver/organizations/{self.organization.slug}/issues/{self.group.id}/?referrer=activity_notification|{self.short_id}> as resolved"
-        )
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=ResolvedActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_regression(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue regresses
-        """
-        notification = RegressionActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.SET_REGRESSION,
-                data={},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        assert text == "Issue marked as regression"
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=RegressionActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_new_processing_issue(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue is held back in reprocessing
-        """
-        data = [
-            {
-                "data": {
-                    "image_arch": "arm64",
-                    "image_path": "/var/containers/Bundle/Application/FB14D416-DE4E-4224-9789-6B88E9C42601/CrashProbeiOS.app/CrashProbeiOS",
-                    "image_uuid": "a2df1794-e0c7-371c-baa4-93eac340a78a",
-                },
-                "object": "dsym:a2df1794-e0c7-371c-baa4-93eac340a78a",
-                "scope": "native",
-                "type": "native_missing_dsym",
-            },
-            {
-                "data": {
-                    "image_arch": "arm64",
-                    "image_path": "/var/containers/Bundle/Application/FB14D416-DE4E-4224-9789-6B88E9C42601/CrashProbeiOS.app/libCrashProbeiOS",
-                    "image_uuid": "12dc1b4c-a01b-463f-ae88-5cf0c31ae680",
-                },
-                "object": "dsym:12dc1b4c-a01b-463f-ae88-5cf0c31ae680",
-                "scope": "native",
-                "type": "native_bad_dsym",
-            },
-        ]
-        notification = NewProcessingIssuesActivityNotification(
-            Activity(
-                project=self.project,
-                user=self.user,
-                type=ActivityType.NEW_PROCESSING_ISSUES,
-                data={
-                    "issues": data,
-                    "reprocessing_active": True,
-                },
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        assert (
-            text
-            == f"Processing issues on <{self.project.slug}|http://testserver/settings/{self.organization.slug}/projects/{self.project.slug}/processing-issues/"
-        )
-        assert (
-            attachment["text"]
-            == f"Some events failed to process in your project {self.project.slug}"
-        )
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=NewProcessingIssuesActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_resolved_in_release(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when an issue is resolved in a release
-        """
-        notification = ResolvedInReleaseActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.SET_RESOLVED_IN_RELEASE,
-                data={"version": "meow"},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        release_name = notification.activity.data["version"]
-        assert text == f"Issue marked as resolved in {release_name} by {self.name}"
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=ResolvedInReleaseActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_note(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when a comment is made on an issue
-        """
-        notification = NoteActivityNotification(
-            Activity(
-                project=self.project,
-                group=self.group,
-                user=self.user,
-                type=ActivityType.NOTE,
-                data={"text": "text", "mentions": []},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-
-        assert text == f"New comment by {self.name}"
-        assert attachment["title"] == f"{self.group.title}"
-        assert (
-            attachment["title_link"]
-            == f"http://testserver/organizations/{self.organization.slug}/issues/{self.group.id}/?referrer=NoteActivitySlack"
-        )
-        assert attachment["text"] == notification.activity.data["text"]
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/workflow/?referrer=NoteActivitySlack|Notification Settings>"
-        )
-
-    @responses.activate
-    @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
-    def test_deploy(self, mock_func):
-        """
-        Test that a Slack message is sent with the expected payload when a deploy happens
-        """
-        release = Release.objects.create(
-            version="meow" * 10,
-            organization_id=self.project.organization_id,
-            date_released=timezone.now(),
-        )
-        project2 = self.create_project(name="battlesnake")
-        release.add_project(self.project)
-        release.add_project(project2)
-        deploy = Deploy.objects.create(
-            release=release,
-            organization_id=self.organization.id,
-            environment_id=self.environment.id,
-        )
-        notification = ReleaseActivityNotification(
-            Activity(
-                project=self.project,
-                user=self.user,
-                type=Activity.RELEASE,
-                data={"version": release.version, "deploy_id": deploy.id},
-            )
-        )
-        with self.tasks():
-            notification.send()
-
-        attachment, text = get_attachment()
-        assert (
-            text
-            == f"Release {release.version} was deployed to {self.environment.name} for these projects"
-        )
-        assert attachment["actions"][0]["text"] == self.project.slug
-        assert (
-            attachment["actions"][0]["url"]
-            == f"http://testserver/organizations/{self.organization.slug}/releases/{release.version}/?project={self.project.id}&unselectedSeries=Healthy/"
-        )
-        assert attachment["actions"][1]["text"] == project2.slug
-        assert (
-            attachment["actions"][1]["url"]
-            == f"http://testserver/organizations/{self.organization.slug}/releases/{release.version}/?project={project2.id}&unselectedSeries=Healthy/"
-        )
-        assert (
-            attachment["footer"]
-            == f"{self.project.slug} | <http://testserver/settings/account/notifications/deploy/?referrer=ReleaseActivitySlack|Notification Settings>"
-        )
 
+class SlackUnassignedNotificationTest(SlackActivityNotificationTest):
     @responses.activate
     @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)
     def test_issue_alert_user(self, mock_func):