def test_link_team_already_linked(self):
"""Test that if a team has already been linked to a Slack channel when a user tries
to link them again, we reject the attempt and reply with the ALREADY_LINKED_MESSAGE"""
ExternalActor.objects.create(
actor_id=self.team.actor_id,
organization=self.organization,
integration=self.integration,
provider=ExternalProviders.SLACK.value,
external_name="general",
external_id="CXXXXXXX9",
)
assert "Link your Sentry team to this Slack channel!" in self.data["text"]
linking_url = build_team_linking_url(
self.integration,
"UXXXXXXX1",
"CXXXXXXX9",
"general",
"http://example.slack.com/response_url",
)
resp = self.client.get(linking_url)
assert resp.status_code == 200
self.assertTemplateUsed(resp, "sentry/integrations/slack/link-team.html")
data = urlencode({"team": self.team.id})
resp = self.client.post(linking_url, data, content_type="application/x-www-form-urlencoded")
assert resp.status_code == 200
self.assertTemplateUsed(resp, "sentry/integrations/slack/post-linked-team.html")
assert len(responses.calls) >= 1
data = json.loads(str(responses.calls[0].request.body.decode("utf-8")))
assert (
f"The {self.team.slug} team has already been linked to a Slack channel." in data["text"]
)
def link_team(self, slack_request: SlackCommandRequest) -> Response:
if slack_request.channel_name == DIRECT_MESSAGE_CHANNEL_NAME:
return self.reply(slack_request, LINK_FROM_CHANNEL_MESSAGE)
identity = self.get_identity(slack_request)
if not identity:
return self.reply(slack_request, LINK_USER_FIRST_MESSAGE)
integration = slack_request.integration
organization = integration.organizations.all()[0]
org_member = OrganizationMember.objects.get(user=identity.user,
organization=organization)
if self.is_team_linked_to_channel(organization, integration,
slack_request):
return self.reply(slack_request, CHANNEL_ALREADY_LINKED_MESSAGE)
if not is_valid_role(org_member):
return self.reply(slack_request, INSUFFICIENT_ROLE_MESSAGE)
associate_url = build_team_linking_url(
integration=slack_request.integration,
slack_id=slack_request.user_id,
channel_id=slack_request.channel_id,
channel_name=slack_request.channel_name,
response_url=slack_request.response_url,
)
return self.reply(
slack_request,
LINK_TEAM_MESSAGE.format(associate_url=associate_url))
def test_link_team_command(self):
"""Test that we successfully link a team to a Slack channel"""
assert "Link your Sentry team to this Slack channel!" in self.data["text"]
linking_url = build_team_linking_url(
self.integration,
"UXXXXXXX1",
"CXXXXXXX9",
"general",
"http://example.slack.com/response_url",
)
resp = self.client.get(linking_url)
assert resp.status_code == 200
self.assertTemplateUsed(resp, "sentry/integrations/slack/link-team.html")
data = urlencode({"team": self.team.id})
resp = self.client.post(linking_url, data, content_type="application/x-www-form-urlencoded")
assert resp.status_code == 200
self.assertTemplateUsed(resp, "sentry/integrations/slack/post-linked-team.html")
assert len(self.external_actor) == 1
assert self.external_actor[0].actor_id == self.team.actor_id
assert len(responses.calls) >= 1
data = json.loads(str(responses.calls[0].request.body.decode("utf-8")))
assert (
f"The {self.team.slug} team will now receive issue alert notifications in the {self.external_actor[0].external_name} channel."
in data["text"]
)
team_settings = NotificationSetting.objects.filter(
scope_type=NotificationScopeType.TEAM.value, target=self.team.actor.id
)
assert len(team_settings) == 1
def link_team(self, slack_request: SlackDMRequest) -> Response:
if slack_request.channel_name == DIRECT_MESSAGE_CHANNEL_NAME:
return self.reply(slack_request, LINK_FROM_CHANNEL_MESSAGE)
identity = get_identity(slack_request)
if not identity:
return self.reply(slack_request, LINK_USER_FIRST_MESSAGE)
integration = slack_request.integration
organization_memberships = OrganizationMember.objects.get_for_integration(
integration, identity.user)
has_valid_role = False
for organization_memberships in organization_memberships:
if is_team_linked_to_channel(organization_memberships.organization,
slack_request):
return self.reply(slack_request,
CHANNEL_ALREADY_LINKED_MESSAGE)
if is_valid_role(organization_memberships):
has_valid_role = True
if not has_valid_role:
return self.reply(slack_request, INSUFFICIENT_ROLE_MESSAGE)
associate_url = build_team_linking_url(
integration=integration,
slack_id=slack_request.user_id,
channel_id=slack_request.channel_id,
channel_name=slack_request.channel_name,
response_url=slack_request.response_url,
)
return self.reply(
slack_request,
LINK_TEAM_MESSAGE.format(associate_url=associate_url))
def test_error_page(self):
"""Test that we successfully render an error page when bad form data is sent."""
assert "Link your Sentry team to this Slack channel!" in self.data[
"text"]
linking_url = build_team_linking_url(
self.integration,
"UXXXXXXX1",
"CXXXXXXX9",
"general",
"http://example.slack.com/response_url",
)
resp = self.client.get(linking_url)
assert resp.status_code == 200
self.assertTemplateUsed(resp,
"sentry/integrations/slack/link-team.html")
data = urlencode({"team": ["some", "garbage"]})
resp = self.client.post(
linking_url,
data,
content_type="application/x-www-form-urlencoded")
assert resp.status_code == 200
self.assertTemplateUsed(
resp, "sentry/integrations/slack/link-team-error.html")
def setUp(self):
super().setUp()
self.url = build_team_linking_url(
integration=self.integration,
slack_id=self.external_id,
channel_id=self.channel_id,
channel_name=self.channel_name,
response_url=self.response_url,
)
def test_link_team_insufficient_role_open_membership(self):
"""Test that when a user whose role is insufficient in an open membership organization
attempts to link a team, we reject them and reply with the INSUFFICIENT_ROLE_MESSAGE"""
self.organization.flags.allow_joinleave = True
user2 = self.create_user()
self.create_member(teams=[self.team],
user=user2,
role="member",
organization=self.organization)
self.login_as(user2)
Identity.objects.create(
external_id="UXXXXXXX2",
idp=self.idp,
user=user2,
status=IdentityStatus.VALID,
scopes=[],
)
assert "Link your Sentry team to this Slack channel!" in self.data[
"text"]
linking_url = build_team_linking_url(
self.integration,
"UXXXXXXX2",
"CXXXXXXX9",
"general",
"http://example.slack.com/response_url",
)
resp = self.client.get(linking_url)
assert resp.status_code == 200
self.assertTemplateUsed(resp,
"sentry/integrations/slack-link-team.html")
data = urlencode({"team": self.team.id})
resp = self.client.post(
linking_url,
data,
content_type="application/x-www-form-urlencoded")
assert resp.status_code == 200
self.assertTemplateUsed(
resp, "sentry/integrations/slack-post-linked-team.html")
assert len(self.external_actor) == 0
assert len(responses.calls) >= 1
data = json.loads(str(responses.calls[0].request.body.decode("utf-8")))
assert "You must be an admin or higher" in data["text"]
def link_team(self, slack_request: SlackCommandRequest) -> Response:
if slack_request.channel_name == DIRECT_MESSAGE_CHANNEL_NAME:
return self.send_ephemeral_notification(LINK_FROM_CHANNEL_MESSAGE)
if not slack_request.has_identity:
return self.send_ephemeral_notification(LINK_USER_FIRST_MESSAGE)
associate_url = build_team_linking_url(
integration=slack_request.integration,
slack_id=slack_request.user_id,
channel_id=slack_request.channel_id,
channel_name=slack_request.channel_name,
response_url=slack_request.response_url,
)
return self.send_ephemeral_notification(
LINK_TEAM_MESSAGE.format(associate_url=associate_url))
def setUp(self):
super().setUp()
self.user = self.create_user("*****@*****.**")
self.org = self.create_organization(name="Rowdy Tiger",
owner=self.user)
self.team = self.create_team(organization=self.org,
name="Mariachi Band")
self.member = self.create_member(
user=None,
email="*****@*****.**",
organization=self.org,
role="owner",
teams=[self.team],
)
self.create_team_membership(user=self.user, team=self.team)
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.org, 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=[],
)
linking_url = urlparse(
build_team_linking_url(
self.integration,
"UXXXXXXX1",
"CXXXXXXX9",
"general",
"http://example.slack.com/response_url",
))
self.path = linking_url.path