def test_resolution_support_with_integration(self, mock_sync_status_outbound):
org = self.create_organization()
integration = Integration.objects.create(provider="example", name="Example")
integration.add_organization(org, self.user)
OrganizationIntegration.objects.filter(
integration_id=integration.id, organization_id=org.id
).update(
config={
"sync_comments": True,
"sync_status_outbound": True,
"sync_status_inbound": True,
"sync_assignee_outbound": True,
"sync_assignee_inbound": True,
}
)
project = self.create_project(organization=org, name="foo")
group = self.create_group(project=project)
add_group_to_inbox(group, GroupInboxReason.MANUAL)
assert GroupInbox.objects.filter(group=group).exists()
external_issue = ExternalIssue.objects.get_or_create(
organization_id=org.id, integration_id=integration.id, key="APP-%s" % group.id
)[0]
GroupLink.objects.get_or_create(
group_id=group.id,
project_id=group.project_id,
linked_type=GroupLink.LinkedType.issue,
linked_id=external_issue.id,
relationship=GroupLink.Relationship.references,
)[0]
repo = Repository.objects.create(organization_id=org.id, name="test/repo")
commit = Commit.objects.create(
organization_id=org.id,
repository_id=repo.id,
message="fixes %s" % (group.qualified_short_id),
key="alksdflskdfjsldkfajsflkslk",
)
release = self.create_release(project=project, version="abcdabc")
with self.tasks():
with self.feature({"organizations:integrations-issue-sync": True}):
release.set_commits([{"id": commit.key, "repository": repo.name}])
mock_sync_status_outbound.assert_called_once_with(external_issue, True, group.project_id)
assert GroupLink.objects.filter(
group_id=group.id, linked_type=GroupLink.LinkedType.commit, linked_id=commit.id
).exists()
resolution = GroupResolution.objects.get(group=group)
assert resolution.status == GroupResolution.Status.resolved
assert resolution.release == release
assert resolution.type == GroupResolution.Type.in_release
assert resolution.actor_id is None
assert Group.objects.get(id=group.id).status == GroupStatus.RESOLVED
assert not GroupInbox.objects.filter(group=group).exists()
def test_remove_from_inbox(self):
add_group_to_inbox(self.group, GroupInboxReason.NEW)
assert GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
remove_group_from_inbox(self.group)
assert not GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
def test_matching_author_without_assignment(self):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.MANUAL)
user = self.create_user(name="Foo Bar", email="*****@*****.**", is_active=True)
email = UserEmail.get_primary_email(user=user)
email.is_verified = True
email.save()
repo = Repository.objects.create(name="example", organization_id=self.group.organization.id)
OrganizationMember.objects.create(organization=group.project.organization, user=user)
UserOption.objects.set_value(user=user, key="self_assign_issue", value="0")
commit = Commit.objects.create(
key=sha1(uuid4().hex.encode("utf-8")).hexdigest(),
organization_id=group.organization.id,
repository_id=repo.id,
message=u"Foo Biz\n\nFixes {}".format(group.qualified_short_id),
author=CommitAuthor.objects.create(
organization_id=group.organization.id, name=user.name, email=user.email
),
)
self.assertResolvedFromCommit(group, commit)
assert not Activity.objects.filter(
project=group.project, group=group, type=Activity.ASSIGNED, user=user
).exists()
assert GroupSubscription.objects.filter(group=group, user=user).exists()
def test_add_to_inbox(self):
add_group_to_inbox(self.group, GroupInboxReason.NEW)
assert GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
add_group_to_inbox(self.group, GroupInboxReason.REGRESSION)
assert GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
def test_resolution_support_without_author(self):
org = self.create_organization()
project = self.create_project(organization=org, name="foo")
group = self.create_group(project=project)
add_group_to_inbox(group, GroupInboxReason.MANUAL)
assert GroupInbox.objects.filter(group=group).exists()
repo = Repository.objects.create(organization_id=org.id,
name="test/repo")
commit = Commit.objects.create(
organization_id=org.id,
repository_id=repo.id,
message="fixes %s" % (group.qualified_short_id),
key="alksdflskdfjsldkfajsflkslk",
)
release = self.create_release(project=project, version="abcdabc")
release.set_commits([{"id": commit.key, "repository": repo.name}])
assert GroupLink.objects.filter(
group_id=group.id,
linked_type=GroupLink.LinkedType.commit,
linked_id=commit.id).exists()
resolution = GroupResolution.objects.get(group=group)
assert resolution.status == GroupResolution.Status.resolved
assert resolution.release == release
assert resolution.type == GroupResolution.Type.in_release
assert resolution.actor_id is None
assert Group.objects.get(id=group.id).status == GroupStatus.RESOLVED
assert not GroupInbox.objects.filter(group=group).exists()
def test_simple(self):
org = self.create_organization()
project = self.create_project(organization=org, name="foo")
group = self.create_group(project=project)
add_group_to_inbox(group, GroupInboxReason.MANUAL)
assert GroupInbox.objects.filter(group=group).exists()
repo = Repository.objects.create(organization_id=org.id, name="test/repo")
commit = Commit.objects.create(
organization_id=org.id,
repository_id=repo.id,
message="fixes %s" % (group.qualified_short_id),
key="alksdflskdfjsldkfajsflkslk",
)
commit2 = Commit.objects.create(
organization_id=org.id,
repository_id=repo.id,
message="i fixed something",
key="lskfslknsdkcsnlkdflksfdkls",
)
assert GroupLink.objects.filter(
group_id=group.id, linked_type=GroupLink.LinkedType.commit, linked_id=commit.id
).exists()
release = Release.objects.create(version="abcdabc", organization=org)
release.add_project(project)
release.set_commits(
[
{"id": commit.key, "repository": repo.name},
{"id": commit2.key, "repository": repo.name},
{"id": "a" * 40, "repository": repo.name},
{"id": "b" * 40, "repository": repo.name, "message": "#skipsentry"},
]
)
assert ReleaseCommit.objects.filter(commit=commit, release=release).exists()
assert ReleaseCommit.objects.filter(commit=commit2, release=release).exists()
assert Group.objects.get(id=group.id).status == GroupStatus.RESOLVED
# test that backfilling works
assert Commit.objects.filter(key="a" * 40, repository_id=repo.id).exists()
assert not Commit.objects.filter(key="b" * 40, repository_id=repo.id).exists()
release = Release.objects.get(id=release.id)
assert release.commit_count == 3
assert release.authors == []
assert release.last_commit_id == commit.id
assert ReleaseHeadCommit.objects.filter(
release_id=release.id, commit_id=commit.id, repository_id=repo.id
).exists()
assert not GroupInbox.objects.filter(group=group).exists()
def test_remove_from_inbox(self, inbox_out):
add_group_to_inbox(self.group, GroupInboxReason.NEW)
assert GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
remove_group_from_inbox(self.group,
user=self.user,
action=GroupInboxRemoveAction.MARK_REVIEWED)
assert not GroupInbox.objects.filter(
group=self.group, reason=GroupInboxReason.NEW.value).exists()
activities = Activity.objects.all()
assert len(activities) == 1
assert activities[0].type == Activity.MARK_REVIEWED
assert inbox_out.called
def test_simple_no_author(self):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.MANUAL)
repo = Repository.objects.create(name="example", organization_id=self.group.organization.id)
commit = Commit.objects.create(
key=sha1(uuid4().hex.encode("utf-8")).hexdigest(),
repository_id=repo.id,
organization_id=group.organization.id,
message=u"Foo Biz\n\nFixes {}".format(group.qualified_short_id),
)
self.assertResolvedFromCommit(group, commit)
def test_ignoring_group(self, send_robust):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.NEW)
request = self.make_request(user=self.user, method="GET")
request.user = self.user
request.data = {"status": "ignored"}
request.GET = QueryDict(query_string="id={}".format(group.id))
search_fn = Mock()
update_groups(request, [self.project], self.organization.id, search_fn)
group.refresh_from_db()
assert group.status == GroupStatus.IGNORED
assert send_robust.called
def test_mark_reviewed_group(self, send_robust):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.NEW)
request = self.make_request(user=self.user, method="GET")
request.user = self.user
request.data = {"inbox": False}
request.GET = QueryDict(query_string=f"id={group.id}")
search_fn = Mock()
update_groups(request, request.GET.getlist("id"), [self.project],
self.organization.id, search_fn)
group.refresh_from_db()
assert not GroupInbox.objects.filter(group=group).exists()
assert send_robust.called
def test_resolving_unresolved_group(self, send_robust):
unresolved_group = self.create_group(status=GroupStatus.UNRESOLVED)
add_group_to_inbox(unresolved_group, GroupInboxReason.NEW)
assert unresolved_group.status == GroupStatus.UNRESOLVED
request = self.make_request(user=self.user, method="GET")
request.user = self.user
request.data = {"status": "resolved"}
request.GET = QueryDict(query_string=f"id={unresolved_group.id}")
search_fn = Mock()
update_groups(request, [self.project], self.organization.id, search_fn)
unresolved_group.refresh_from_db()
assert unresolved_group.status == GroupStatus.RESOLVED
assert not GroupInbox.objects.filter(group=unresolved_group).exists()
assert send_robust.called
def test_resolution_support_full_featured(self):
org = self.create_organization(owner=self.user)
project = self.create_project(organization=org, name="foo")
group = self.create_group(project=project)
add_group_to_inbox(group, GroupInboxReason.MANUAL)
assert GroupInbox.objects.filter(group=group).exists()
repo = Repository.objects.create(organization_id=org.id,
name="test/repo")
author = CommitAuthor.objects.create(organization_id=org.id,
name="Foo Bar",
email=self.user.email)
commit = Commit.objects.create(
organization_id=org.id,
repository_id=repo.id,
message="fixes %s" % (group.qualified_short_id),
key="alksdflskdfjsldkfajsflkslk",
author=author,
)
old_release = self.create_release(project=project, version="pre-1.0")
resolution = GroupResolution.objects.create(
group=group,
release=old_release,
type=GroupResolution.Type.in_next_release,
status=GroupResolution.Status.pending,
)
release = self.create_release(project=project, version="abcdabc")
release.set_commits([{"id": commit.key, "repository": repo.name}])
assert GroupLink.objects.filter(
group_id=group.id,
linked_type=GroupLink.LinkedType.commit,
linked_id=commit.id).exists()
resolution = GroupResolution.objects.get(group=group)
assert resolution.status == GroupResolution.Status.resolved
assert resolution.release == release
assert resolution.type == GroupResolution.Type.in_release
assert resolution.actor_id == self.user.id
assert Group.objects.get(id=group.id).status == GroupStatus.RESOLVED
assert not GroupInbox.objects.filter(group=group).exists()
def test_resolving_unresolved_group(self, send_robust):
unresolved_group = self.create_group(status=GroupStatus.UNRESOLVED)
add_group_to_inbox(unresolved_group, GroupInboxReason.NEW)
assert unresolved_group.status == GroupStatus.UNRESOLVED
request = self.make_request(user=self.user, method="GET")
request.user = self.user
request.data = {"status": "resolved"}
request.GET = QueryDict(query_string="id={}".format(unresolved_group.id))
search_fn = Mock()
update_groups(request, [self.project], self.organization.id, search_fn)
unresolved_group.refresh_from_db()
assert unresolved_group.status == GroupStatus.RESOLVED
# TODO: Chris F.: This is temporarily removed while we perform some migrations.
# assert not GroupInbox.objects.filter(group=unresolved_group).exists()
assert send_robust.called
def test_updating_commit_with_existing_grouplink(self):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.MANUAL)
repo = Repository.objects.create(
name="example", organization_id=self.group.organization.id)
commit = Commit.objects.create(
key=sha1(uuid4().hex.encode("utf-8")).hexdigest(),
repository_id=repo.id,
organization_id=group.organization.id,
message=f"Foo Biz\n\nFixes {group.qualified_short_id}",
)
self.assertResolvedFromCommit(group, commit)
commit.message = f"Foo Bar Biz\n\nFixes {group.qualified_short_id}"
commit.save()
self.assertResolvedFromCommit(group, commit)
def test_removes_group_link_when_message_changes(self):
group = self.create_group()
add_group_to_inbox(group, GroupInboxReason.MANUAL)
repo = Repository.objects.create(name="example", organization_id=self.group.organization.id)
commit = Commit.objects.create(
key=sha1(uuid4().hex.encode("utf-8")).hexdigest(),
repository_id=repo.id,
organization_id=group.organization.id,
message="Foo Biz\n\nFixes {}".format(group.qualified_short_id),
)
self.assertResolvedFromCommit(group, commit)
commit.message = "no groups here"
commit.save()
add_group_to_inbox(group, GroupInboxReason.MANUAL)
self.assertNotResolvedFromCommit(group, commit)
def test_invalid_reason_details(self):
reason_details = {"meow": 123}
add_group_to_inbox(self.group, GroupInboxReason.NEW, reason_details)
assert GroupInbox.objects.get(group=self.group.id).reason_details is None
def test_backfilling_commits(self):
org = self.create_organization()
project = self.create_project(organization=org, name="foo")
group = self.create_group(project=project)
add_group_to_inbox(group, GroupInboxReason.MANUAL)
assert GroupInbox.objects.filter(group=group).exists()
repo = Repository.objects.create(organization_id=org.id,
name="test/repo")
commit = Commit.objects.create(repository_id=repo.id,
organization_id=org.id,
key="b" * 40)
release = Release.objects.create(version="abcdabc", organization=org)
release.add_project(project)
release.set_commits([
{
"id": "a" * 40,
"repository": repo.name,
"author_email":
"*****@*****.**", # throw in an upper case letter
"author_name": "foo bar baz",
"message": "i fixed a bug",
},
{
"id": "b" * 40,
"repository": repo.name,
"author_email": "*****@*****.**",
"author_name": "foo bar baz",
"message": "i fixed another bug",
},
{
"id": "c" * 40,
"repository": repo.name,
"author_email": "*****@*****.**",
"author_name": "foo bar baz",
"message": "fixes %s" % (group.qualified_short_id),
},
])
author = CommitAuthor.objects.get(name="foo bar baz",
email="*****@*****.**",
organization_id=org.id)
commit_a = Commit.objects.get(repository_id=repo.id,
organization_id=org.id,
key="a" * 40)
assert commit_a
assert commit_a.message == "i fixed a bug"
assert commit_a.author_id == author.id
commit_c = Commit.objects.get(repository_id=repo.id,
organization_id=org.id,
key="c" * 40)
assert commit_c
assert "fixes" in commit_c.message
assert commit_c.author_id == author.id
# test that backfilling fills in missing message and author
commit = Commit.objects.get(id=commit.id)
assert commit.message == "i fixed another bug"
assert commit.author_id == author.id
assert ReleaseCommit.objects.filter(commit__key="a" * 40,
commit__repository_id=repo.id,
release=release).exists()
assert ReleaseCommit.objects.filter(commit__key="b" * 40,
commit__repository_id=repo.id,
release=release).exists()
assert ReleaseCommit.objects.filter(commit__key="c" * 40,
commit__repository_id=repo.id,
release=release).exists()
assert GroupLink.objects.filter(
group_id=group.id,
linked_type=GroupLink.LinkedType.commit,
linked_id=commit_c.id).exists()
assert GroupResolution.objects.filter(group=group,
release=release).exists()
assert (GroupResolution.objects.get(
group=group,
release=release).status == GroupResolution.Status.resolved)
assert Group.objects.get(id=group.id).status == GroupStatus.RESOLVED
latest_commit = Commit.objects.get(repository_id=repo.id, key="a" * 40)
release = Release.objects.get(id=release.id)
assert release.commit_count == 3
assert release.authors == [six.text_type(author.id)]
assert release.last_commit_id == latest_commit.id
assert not GroupInbox.objects.filter(group=group).exists()
