def test_codeowner_links(self):
org = self.create_organization()
project = self.create_project(organization=org)
integration = Integration.objects.create(provider="example",
name="Example")
repository = self.create_repo(project=project,
name="testrepo",
provider="gitlab",
integration_id=integration.id)
organization_integration = integration.add_organization(org, self.user)
code_mapping = self.create_code_mapping(
project=project,
repo=repository,
organization_integration=organization_integration)
code_owner = self.create_codeowners(project=project,
code_mapping=code_mapping)
organization_integration.update(status=ObjectStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(organization_integration, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not OrganizationIntegration.objects.filter(
id=organization_integration.id).exists()
# We expect to delete all associated Code Owners and Code Mappings
assert not ProjectCodeOwners.objects.filter(id=code_owner.id).exists()
assert not RepositoryProjectPathConfig.objects.filter(
id=code_owner.id).exists()
def test_simple(self):
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example',
)
repo2 = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example2',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=org.id,
key='1234abcd',
)
commit2 = Commit.objects.create(
repository_id=repo2.id,
organization_id=org.id,
key='1234abcd',
)
deletion = ScheduledDeletion.schedule(repo, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Repository.objects.filter(id=repo.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
assert Commit.objects.filter(id=commit2.id).exists()
def test_simple(self):
org = self.create_organization()
integration = Integration.objects.create(
provider='example',
name='Example',
)
integration.add_organization(org, self.user)
organization_integration = OrganizationIntegration.objects.get(
integration_id=integration.id,
organization_id=org.id,
)
external_issue = ExternalIssue.objects.create(
organization_id=org.id,
integration_id=integration.id,
key='ABC-123',
)
deletion = ScheduledDeletion.schedule(organization_integration, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not OrganizationIntegration.objects.filter(
id=organization_integration.id).exists()
assert not ExternalIssue.objects.filter(id=external_issue.id).exists()
def test_simple(self):
app = ApiApplication.objects.create(
owner=self.user,
)
ApiToken.objects.create(
application=app,
user=self.user,
scopes=0,
)
ApiGrant.objects.create(
application=app,
user=self.user,
scopes=0,
redirect_uri='http://example.com',
)
deletion = ScheduledDeletion.schedule(app, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not ApiApplication.objects.filter(id=app.id).exists()
assert not ApiGrant.objects.filter(application=app).exists()
assert not ApiToken.objects.filter(application=app).exists()
def test_simple(self):
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example',
)
repo2 = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example2',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=org.id,
key='1234abcd',
)
commit2 = Commit.objects.create(
repository_id=repo2.id,
organization_id=org.id,
key='1234abcd',
)
deletion = ScheduledDeletion.schedule(repo, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Repository.objects.filter(id=repo.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
assert Commit.objects.filter(id=commit2.id).exists()
def test_orphan_commits(self):
# We have had a few orgs get into a state where they have commits
# but no repositories. Ensure that we can proceed.
org = self.create_organization(name="test")
repo = Repository.objects.create(organization_id=org.id,
name=org.name,
provider="dummy")
author = CommitAuthor.objects.create(organization_id=org.id,
name="foo",
email="*****@*****.**")
commit = Commit.objects.create(repository_id=repo.id,
organization_id=org.id,
author=author,
key="a" * 40)
# Simulate the project being deleted but the deletion crashing.
repo.delete()
org.update(status=OrganizationStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Organization.objects.filter(id=org.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
assert not CommitAuthor.objects.filter(id=author.id).exists()
def test_simple(self):
event_id = "a" * 32
project = self.create_project()
node_id = Event.generate_node_id(project.id, event_id)
group = self.create_group(project=project)
event = self.create_event(group=group, event_id=event_id)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(name="hello.png", type="image/png"),
name="hello.png",
)
UserReport.objects.create(
event_id=event.event_id, project_id=event.project_id, name="Jane Bloggs"
)
assert nodestore.get(node_id) is not None
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id, project_id=project.id
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id, project_id=project.id
).exists()
assert nodestore.get(node_id) is None
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider="dummy",
name="example/example",
status=ObjectStatus.PENDING_DELETION,
)
repo2 = Repository.objects.create(organization_id=org.id,
provider="dummy",
name="example/example2")
commit = Commit.objects.create(repository_id=repo.id,
organization_id=org.id,
key="1234abcd")
commit2 = Commit.objects.create(repository_id=repo2.id,
organization_id=org.id,
key="1234abcd")
deletion = ScheduledDeletion.schedule(repo, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Repository.objects.filter(id=repo.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
assert Commit.objects.filter(id=commit2.id).exists()
def test_alert_rule(self):
org = self.create_organization(name="test", owner=self.user)
self.create_team(organization=org, name="test1")
env = Environment.objects.create(organization_id=org.id, name="foo")
snuba_query = SnubaQuery.objects.create(dataset="events",
aggregate="count()",
time_window=60,
resolution=60,
environment=env)
alert_rule = AlertRule.objects.create(
organization=org,
name="rule with environment",
threshold_period=1,
snuba_query=snuba_query,
# This status is hidden from the default finder.
status=AlertRuleStatus.SNAPSHOT.value,
)
org.update(status=OrganizationStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Organization.objects.filter(id=org.id).exists()
assert not Environment.objects.filter(id=env.id).exists()
assert not AlertRule.objects.filter(id=alert_rule.id).exists()
assert not SnubaQuery.objects.filter(id=snuba_query.id).exists()
def test_discover_query_cleanup(self):
org = self.create_organization(name="test", owner=self.user)
self.create_team(organization=org, name="test1")
other = self.create_organization(name="other", owner=self.user)
other_project = self.create_project(organization=other,
name="other project")
query = DiscoverSavedQuery.objects.create(organization=org,
name="test query",
query="{}")
# Make a cross-org project reference. This can happen when an account was
# merged in the past and we didn't update the discover queries.
query_project = DiscoverSavedQueryProject.objects.create(
discover_saved_query=query, project=other_project)
org.update(status=OrganizationStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Organization.objects.filter(id=org.id).exists()
assert not DiscoverSavedQuery.objects.filter(id=query.id).exists()
assert not DiscoverSavedQueryProject.objects.filter(
id=query_project.id).exists()
def test_simple(self):
org = self.create_organization()
integration = Integration.objects.create(
provider='example',
name='Example',
)
integration.add_organization(org, self.user)
organization_integration = OrganizationIntegration.objects.get(
integration_id=integration.id,
organization_id=org.id,
)
external_issue = ExternalIssue.objects.create(
organization_id=org.id,
integration_id=integration.id,
key='ABC-123',
)
deletion = ScheduledDeletion.schedule(organization_integration, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not OrganizationIntegration.objects.filter(id=organization_integration.id).exists()
assert not ExternalIssue.objects.filter(id=external_issue.id).exists()
def test_large_child_relation_deletion(self):
org = self.create_organization(name="test")
self.create_team(organization=org, name="test1")
repo = Repository.objects.create(organization_id=org.id,
name=org.name,
provider="dummy")
author_bob = CommitAuthor.objects.create(organization_id=org.id,
name="bob",
email="*****@*****.**")
author_sally = CommitAuthor.objects.create(organization_id=org.id,
name="sally",
email="*****@*****.**")
# Make >100 commits so we can ensure that all commits are removed before authors are.
for i in range(0, 150):
author = author_bob if i % 2 == 0 else author_sally
Commit.objects.create(repository_id=repo.id,
organization_id=org.id,
author=author,
key=uuid4().hex)
org.update(status=OrganizationStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Organization.objects.filter(id=org.id).exists()
assert not Commit.objects.filter(organization_id=org.id).exists()
assert not CommitAuthor.objects.filter(organization_id=org.id).exists()
def test_simple(self):
org = self.create_organization(
name='test',
)
org2 = self.create_organization(name='test2')
self.create_team(organization=org, name='test1')
self.create_team(organization=org, name='test2')
release = Release.objects.create(version='a' * 32,
organization_id=org.id)
repo = Repository.objects.create(
organization_id=org.id,
name=org.name,
)
commit_author = CommitAuthor.objects.create(
organization_id=org.id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=org.id,
author=commit_author,
key='a' * 40,
)
ReleaseCommit.objects.create(
organization_id=org.id,
release=release,
commit=commit,
order=0,
)
env = Environment.objects.create(
organization_id=org.id,
project_id=4,
name='foo'
)
release_env = ReleaseEnvironment.objects.create(
organization_id=org.id,
project_id=4,
release_id=release.id,
environment_id=env.id
)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert Organization.objects.filter(id=org2.id).exists()
assert not Organization.objects.filter(id=org.id).exists()
assert not Environment.objects.filter(id=env.id).exists()
assert not ReleaseEnvironment.objects.filter(id=release_env.id).exists()
assert not Repository.objects.filter(id=repo.id).exists()
assert not ReleaseCommit.objects.filter(organization_id=org.id).exists()
assert not Release.objects.filter(organization_id=org.id).exists()
assert not CommitAuthor.objects.filter(id=commit_author.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
tk = TagKey.objects.create(key='foo', project_id=project.id)
TagValue.objects.create(key='foo', value='bar', project_id=project.id)
GroupTagKey.objects.create(key='foo',
group_id=group.id,
project_id=project.id)
GroupTagValue.objects.create(key='foo',
value='bar',
group_id=group.id,
project_id=project.id)
EventTag.objects.create(
key_id=tk.id,
group_id=group.id,
value_id=1,
project_id=project.id,
event_id=1,
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = TagKey.objects.create(key='foo', project_id=project2.id)
gtk2 = GroupTagKey.objects.create(key='foo',
group_id=group2.id,
project_id=project2.id)
gtv2 = GroupTagValue.objects.create(key='foo',
value='bar',
group_id=group2.id,
project_id=project2.id)
EventTag.objects.create(
key_id=tk2.id,
group_id=group2.id,
value_id=1,
project_id=project.id,
event_id=1,
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not GroupTagValue.objects.filter(
key=tk.key, project_id=project.id).exists()
assert not GroupTagKey.objects.filter(key=tk.key,
project_id=project.id).exists()
assert not TagValue.objects.filter(key=tk.key,
project_id=project.id).exists()
assert not TagKey.objects.filter(id=tk.id).exists()
assert not EventTag.objects.filter(key_id=tk.id).exists()
assert TagKey.objects.filter(id=tk2.id).exists()
assert GroupTagKey.objects.filter(id=gtk2.id).exists()
assert GroupTagValue.objects.filter(id=gtv2.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project(
name='test',
)
group = self.create_group(project=project)
GroupAssignee.objects.create(group=group, project=project, user=self.user)
GroupMeta.objects.create(group=group, key='foo', value='bar')
release = Release.objects.create(version='a' * 32,
organization_id=project.organization_id)
release.add_project(project)
GroupResolution.objects.create(group=group, release=release)
env = Environment.objects.create(
organization_id=project.organization_id,
project_id=project.id,
name='foo'
)
env.add_project(project)
repo = Repository.objects.create(
organization_id=project.organization_id,
name=project.name,
)
commit_author = CommitAuthor.objects.create(
organization_id=project.organization_id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=project.organization_id,
author=commit_author,
key='a' * 40,
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=0,
)
deletion = ScheduledDeletion.schedule(project, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Project.objects.filter(id=project.id).exists()
assert not EnvironmentProject.objects.filter(
project_id=project.id,
environment_id=env.id
).exists()
assert Environment.objects.filter(id=env.id).exists()
assert Release.objects.filter(id=release.id).exists()
assert ReleaseCommit.objects.filter(release_id=release.id).exists()
assert Commit.objects.filter(id=commit.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(1, 1),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_no_delete_visible(self):
org = self.create_organization()
repo = Repository.objects.create(organization_id=org.id,
provider="dummy",
name="example/example")
deletion = ScheduledDeletion.schedule(repo, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert Repository.objects.filter(id=repo.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
tags=[
(1, 1),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventMapping.objects.filter(
event_id='a' * 32,
group_id=group.id,
).exists()
assert not tagstore.get_event_tag_qs(event_id=event.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
team = self.create_team(name='test', )
self.create_project(team=team, name='test1')
self.create_project(team=team, name='test2')
deletion = ScheduledDeletion.schedule(team, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Team.objects.filter(id=team.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(project=project, )
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def test_simple(self):
org = self.create_organization(
name='test',
)
org2 = self.create_organization(name='test2')
self.create_team(organization=org, name='test1')
self.create_team(organization=org, name='test2')
release = Release.objects.create(version='a' * 32, organization_id=org.id)
repo = Repository.objects.create(
organization_id=org.id,
name=org.name,
provider='dummy',
)
commit_author = CommitAuthor.objects.create(
organization_id=org.id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=org.id,
author=commit_author,
key='a' * 40,
)
ReleaseCommit.objects.create(
organization_id=org.id,
release=release,
commit=commit,
order=0,
)
env = Environment.objects.create(organization_id=org.id, project_id=4, name='foo')
release_env = ReleaseEnvironment.objects.create(
organization_id=org.id, project_id=4, release_id=release.id, environment_id=env.id
)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert Organization.objects.filter(id=org2.id).exists()
assert not Organization.objects.filter(id=org.id).exists()
assert not Environment.objects.filter(id=env.id).exists()
assert not ReleaseEnvironment.objects.filter(id=release_env.id).exists()
assert not Repository.objects.filter(id=repo.id).exists()
assert not ReleaseCommit.objects.filter(organization_id=org.id).exists()
assert not Release.objects.filter(organization_id=org.id).exists()
assert not CommitAuthor.objects.filter(id=commit_author.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
def test_simple(self):
project = self.create_project(name='test', )
group = self.create_group(project=project)
GroupAssignee.objects.create(group=group,
project=project,
user=self.user)
GroupMeta.objects.create(group=group, key='foo', value='bar')
release = Release.objects.create(
version='a' * 32, organization_id=project.organization_id)
release.add_project(project)
GroupResolution.objects.create(group=group, release=release)
env = Environment.objects.create(
organization_id=project.organization_id,
project_id=project.id,
name='foo')
env.add_project(project)
repo = Repository.objects.create(
organization_id=project.organization_id,
name=project.name,
)
commit_author = CommitAuthor.objects.create(
organization_id=project.organization_id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=project.organization_id,
author=commit_author,
key='a' * 40,
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=0,
)
deletion = ScheduledDeletion.schedule(project, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Project.objects.filter(id=project.id).exists()
assert not EnvironmentProject.objects.filter(
project_id=project.id, environment_id=env.id).exists()
assert Environment.objects.filter(id=env.id).exists()
assert Release.objects.filter(id=release.id).exists()
assert ReleaseCommit.objects.filter(release_id=release.id).exists()
assert Commit.objects.filter(id=commit.id).exists()
def test_no_delete_visible(self):
org = self.create_organization(name="test")
release = Release.objects.create(version="a" * 32, organization_id=org.id)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
assert org.status == OrganizationStatus.ACTIVE
with self.tasks():
run_deletion(deletion.id)
assert Organization.objects.filter(id=org.id).exists()
assert Release.objects.filter(id=release.id).exists()
assert not ScheduledDeletion.objects.filter(id=deletion.id).exists()
def test_skip_on_undelete(self):
org = self.create_organization()
integration = Integration.objects.create(provider="example",
name="Example")
organization_integration = integration.add_organization(org, self.user)
deletion = ScheduledDeletion.schedule(organization_integration, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert OrganizationIntegration.objects.filter(
id=organization_integration.id).exists()
def test_simple(self):
app = ApiApplication.objects.create(owner=self.user)
ApiToken.objects.create(application=app, user=self.user, scopes=0)
ApiGrant.objects.create(
application=app, user=self.user, scopes=0, redirect_uri="http://example.com"
)
deletion = ScheduledDeletion.schedule(app, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not ApiApplication.objects.filter(id=app.id).exists()
assert not ApiGrant.objects.filter(application=app).exists()
assert not ApiToken.objects.filter(application=app).exists()
def test_simple(self):
key = "key"
value = "value"
event_id = "a" * 32
project = self.create_project()
event = self.store_event(
data={
"event_id": event_id,
"tags": {
key: value
},
"timestamp": iso_format(before_now(minutes=1)),
},
project_id=project.id,
)
group = event.group
group.update(status=GroupStatus.PENDING_DELETION)
project = self.create_project()
group = self.create_group(project=project)
event = self.create_event(group=group)
UserReport.objects.create(group_id=group.id,
project_id=event.project_id,
name="Jane Doe")
GroupAssignee.objects.create(group=group,
project=project,
user=self.user)
GroupHash.objects.create(project=project,
group=group,
hash=uuid4().hex)
GroupMeta.objects.create(group=group, key="foo", value="bar")
GroupRedirect.objects.create(group_id=group.id, previous_group_id=1)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
event_id = "a" * 32
project = self.create_project()
node_id = Event.generate_node_id(project.id, event_id)
group = self.create_group(project=project)
event = self.create_event(group=group, event_id=event_id)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(name="hello.png", type="image/png"),
name="hello.png",
)
UserReport.objects.create(event_id=event.event_id,
project_id=event.project_id,
name="Jane Doe")
key = "key"
value = "value"
tk = tagstore.create_tag_key(project_id=project.id,
environment_id=self.environment.id,
key=key)
tv = tagstore.create_tag_value(project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[(tk.key, tv.value)],
)
assert nodestore.get(node_id) is not None
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id, project_id=project.id).exists()
assert not UserReport.objects.filter(event_id=event.event_id,
project_id=project.id).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert nodestore.get(node_id) is None
def test_simple(self):
team = self.create_team(name="test")
project1 = self.create_project(teams=[team], name="test1")
project2 = self.create_project(teams=[team], name="test2")
assert project1.teams.first() == team
assert project2.teams.first() == team
deletion = ScheduledDeletion.schedule(team, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Team.objects.filter(id=team.id).exists()
assert Project.objects.filter(id=project1.id).exists()
assert Project.objects.filter(id=project2.id).exists()
assert not ProjectTeam.objects.filter(team_id=team.id).exists()
def test_group_first_release(self):
org = self.create_organization(name="test")
project = self.create_project(organization=org)
release = self.create_release(project=project, user=self.user, version="1.2.3")
group = Group.objects.create(project=project, first_release=release)
# Simulate the project being deleted but the deletion crashing.
project.delete()
org.update(status=OrganizationStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Group.objects.filter(id=group.id).exists()
assert not Organization.objects.filter(id=org.id).exists()
def test_delete_fail_email_random(self, mock_delete_repo):
mock_delete_repo.side_effect = Exception("secrets")
org = self.create_organization()
repo = Repository.objects.create(organization_id=org.id,
provider="dummy",
name="example/example")
deletion = ScheduledDeletion.schedule(repo, actor=self.user, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
msg = mail.outbox[-1]
assert msg.subject == "Unable to Delete Repository Webhooks"
assert msg.to == [self.user.email]
assert "secrets" not in msg.body
assert not Repository.objects.filter(id=repo.id).exists()
def test_simple(self):
team = self.create_team(
name='test',
)
project1 = self.create_project(team=team, name='test1')
project2 = self.create_project(team=team, name='test2')
assert project1.teams.first() == team
assert project2.teams.first() == team
deletion = ScheduledDeletion.schedule(team, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Team.objects.filter(id=team.id).exists()
assert not Project.objects.filter(id=project1.id).exists()
assert not Project.objects.filter(id=project2.id).exists()
assert not ProjectTeam.objects.filter(team_id=team.id).exists()
def test_simple(self):
org = self.create_organization()
integration = Integration.objects.create(provider="example",
name="Example")
organization_integration = integration.add_organization(org, self.user)
external_issue = ExternalIssue.objects.create(
organization_id=org.id,
integration_id=integration.id,
key="ABC-123")
organization_integration.update(status=ObjectStatus.PENDING_DELETION)
deletion = ScheduledDeletion.schedule(organization_integration, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not OrganizationIntegration.objects.filter(
id=organization_integration.id).exists()
assert not ExternalIssue.objects.filter(id=external_issue.id).exists()
def test_simple(self):
org = self.create_organization()
project = self.create_project(organization=org)
env = self.create_environment(organization=org)
release = self.create_release(project=project, environments=[env])
file = self.create_release_file(release_id=release.id)
deletion = ScheduledDeletion.schedule(release, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Release.objects.filter(id=release.id).exists()
assert not ReleaseCommit.objects.filter(release=release).exists()
assert not ReleaseEnvironment.objects.filter(release=release).exists()
assert not ReleaseFile.objects.filter(id=file.id).exists()
# Shared objects should continue to exist.
assert Environment.objects.filter(id=env.id).exists()
assert Project.objects.filter(id=project.id).exists()
def test_botched_deletion(self):
repo = Repository.objects.create(
organization_id=self.organization.id,
provider="dummy",
name="example/example",
status=ObjectStatus.PENDING_DELETION,
)
# Left over from a botched deletion.
OrganizationOption.objects.create(
organization_id=self.organization.id,
key=repo.build_pending_deletion_key(),
value="",
)
deletion = ScheduledDeletion.schedule(repo, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Repository.objects.filter(id=repo.id).exists()
def test_delete_fail_email(self, mock_delete_repo):
mock_delete_repo.side_effect = PluginError('foo')
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example',
)
deletion = ScheduledDeletion.schedule(repo, actor=self.user, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
msg = mail.outbox[-1]
assert msg.subject == 'Unable to Delete Repository Webhooks'
assert msg.to == [self.user.email]
assert 'foo' in msg.body
assert not Repository.objects.filter(id=repo.id).exists()
def test_delete_fail_email_random(self, mock_delete_repo):
mock_delete_repo.side_effect = Exception('secrets')
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example',
)
deletion = ScheduledDeletion.schedule(repo, actor=self.user, days=0)
deletion.update(in_progress=True)
with self.assertRaises(Exception):
with self.tasks():
run_deletion(deletion.id)
msg = mail.outbox[-1]
assert msg.subject == 'Unable to Delete Repository'
assert msg.to == [self.user.email]
assert 'secrets' not in msg.body
def test_delete_fail_email_random(self, mock_delete_repo):
mock_delete_repo.side_effect = Exception('secrets')
org = self.create_organization()
repo = Repository.objects.create(
organization_id=org.id,
provider='dummy',
name='example/example',
)
deletion = ScheduledDeletion.schedule(repo, actor=self.user, days=0)
deletion.update(in_progress=True)
with self.assertRaises(Exception):
with self.tasks():
run_deletion(deletion.id)
msg = mail.outbox[-1]
assert msg.subject == 'Unable to Delete Repository'
assert msg.to == [self.user.email]
assert 'secrets' not in msg.body
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
tk = TagKey.objects.create(key='foo', project=project)
TagValue.objects.create(key='foo', value='bar', project=project)
GroupTagKey.objects.create(key='foo', group=group, project=project)
GroupTagValue.objects.create(key='foo', value='bar', group_id=group.id, project_id=project.id)
EventTag.objects.create(
key_id=tk.id, group_id=group.id, value_id=1, project_id=project.id,
event_id=1,
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = TagKey.objects.create(key='foo', project=project2)
gtk2 = GroupTagKey.objects.create(key='foo', group=group2, project=project2)
gtv2 = GroupTagValue.objects.create(key='foo', value='bar', group_id=group2.id, project_id=project2.id)
EventTag.objects.create(
key_id=tk2.id, group_id=group2.id, value_id=1, project_id=project.id,
event_id=1,
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not GroupTagValue.objects.filter(key=tk.key, project_id=project.id).exists()
assert not GroupTagKey.objects.filter(key=tk.key, project=project).exists()
assert not TagValue.objects.filter(key=tk.key, project=project).exists()
assert not TagKey.objects.filter(id=tk.id).exists()
assert not EventTag.objects.filter(key_id=tk.id).exists()
assert TagKey.objects.filter(id=tk2.id).exists()
assert GroupTagKey.objects.filter(id=gtk2.id).exists()
assert GroupTagValue.objects.filter(id=gtv2.id).exists()
assert EventTag.objects.filter(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventMapping.objects.create(
project_id=project.id,
event_id='a' * 32,
group_id=group.id,
)
EventAttachment.objects.create(
event_id=event.event_id,
group_id=event.group_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
group_id=group.id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
GroupAssignee.objects.create(
group=group,
project=project,
user=self.user,
)
GroupHash.objects.create(
project=project,
group=group,
hash=uuid4().hex,
)
GroupMeta.objects.create(
group=group,
key='foo',
value='bar',
)
GroupRedirect.objects.create(
group_id=group.id,
previous_group_id=1,
)
deletion = ScheduledDeletion.schedule(group, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
group_id=group.id,
).exists()
assert not EventMapping.objects.filter(
group_id=group.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
assert not UserReport.objects.filter(group_id=group.id).exists()
assert not GroupRedirect.objects.filter(group_id=group.id).exists()
assert not GroupHash.objects.filter(group_id=group.id).exists()
assert not Group.objects.filter(id=group.id).exists()
def test_simple(self):
team = self.create_team(name='test', slug='test')
project = self.create_project(team=team, name='test1', slug='test1')
group = self.create_group(project=project)
key = 'foo'
value = 'bar'
tk = tagstore.create_tag_key(
key=key,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_tag_value(
key=key,
value=value,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_key(
key=key,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group.id, project_id=project.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group.id,
project_id=project.id,
event_id=1,
tags=[
(tk.id, 1),
]
)
project2 = self.create_project(team=team, name='test2')
group2 = self.create_group(project=project2)
tk2 = tagstore.create_tag_key(project2.id, self.environment.id, key)
tagstore.create_group_tag_key(
key=key,
group_id=group2.id,
project_id=project2.id,
environment_id=self.environment.id)
tagstore.create_group_tag_value(
key=key, value=value, group_id=group2.id, project_id=project2.id, environment_id=self.environment.id
)
tagstore.create_event_tags(
group_id=group2.id,
project_id=project.id,
event_id=1,
tags=[
(tk2.id, 1),
],
)
deletion = ScheduledDeletion.schedule(tk, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
try:
tagstore.get_group_tag_value(group.id, key, value)
assert False # verify exception thrown
except tagstore.GroupTagValueNotFound:
pass
try:
tagstore.get_group_tag_key(group.id, key)
assert False # verify exception thrown
except tagstore.GroupTagKeyNotFound:
pass
try:
tagstore.get_tag_value(project.id, key, value)
assert False # verify exception thrown
except tagstore.TagValueNotFound:
pass
try:
tagstore.get_tag_key(project.id, key)
assert False # verify exception thrown
except tagstore.TagKeyNotFound:
pass
assert tagstore.get_tag_key(project2.id, key) is not None
assert tagstore.get_group_tag_key(group2.id, key) is not None
assert tagstore.get_group_tag_value(group2.id, key, value) is not None
assert tagstore.get_event_tag_qs(key_id=tk.id).exists()
assert tagstore.get_event_tag_qs(key_id=tk2.id).exists()
def test_simple(self):
project = self.create_project(
name='test',
)
group = self.create_group(project=project)
event = self.create_event(group=group)
GroupAssignee.objects.create(group=group, project=project, user=self.user)
GroupMeta.objects.create(group=group, key='foo', value='bar')
release = Release.objects.create(version='a' * 32, organization_id=project.organization_id)
release.add_project(project)
GroupResolution.objects.create(group=group, release=release)
env = Environment.objects.create(
organization_id=project.organization_id, project_id=project.id, name='foo'
)
env.add_project(project)
repo = Repository.objects.create(
organization_id=project.organization_id,
name=project.name,
)
commit_author = CommitAuthor.objects.create(
organization_id=project.organization_id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=project.organization_id,
author=commit_author,
key='a' * 40,
)
ReleaseCommit.objects.create(
organization_id=project.organization_id,
project_id=project.id,
release=release,
commit=commit,
order=0,
)
file = File.objects.create(
name='debug-file',
type='project.dif',
)
dif = ProjectDebugFile.objects.create(
file=file,
debug_id='uuid',
cpu_name='cpu',
object_name='object',
project=project,
)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
deletion = ScheduledDeletion.schedule(project, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Project.objects.filter(id=project.id).exists()
assert not EnvironmentProject.objects.filter(
project_id=project.id, environment_id=env.id
).exists()
assert Environment.objects.filter(id=env.id).exists()
assert not Group.objects.filter(project_id=project.id).exists()
assert not Event.objects.filter(project_id=project.id).exists()
assert not EventAttachment.objects.filter(project_id=project.id).exists()
assert Release.objects.filter(id=release.id).exists()
assert ReleaseCommit.objects.filter(release_id=release.id).exists()
assert Commit.objects.filter(id=commit.id).exists()
assert not ProjectDebugFile.objects.filter(id=dif.id).exists()
assert not File.objects.filter(id=file.id).exists()
def test_simple(self):
project = self.create_project()
group = self.create_group(
project=project,
)
event = self.create_event(group=group)
EventAttachment.objects.create(
event_id=event.event_id,
project_id=event.project_id,
file=File.objects.create(
name='hello.png',
type='image/png',
),
name='hello.png',
)
UserReport.objects.create(
event_id=event.event_id,
project_id=event.project_id,
name='Jane Doe',
)
key = 'key'
value = 'value'
tk = tagstore.create_tag_key(
project_id=project.id,
environment_id=self.environment.id,
key=key
)
tv = tagstore.create_tag_value(
project_id=project.id,
environment_id=self.environment.id,
key=key,
value=value
)
tagstore.create_event_tags(
event_id=event.id,
group_id=group.id,
project_id=project.id,
environment_id=self.environment.id,
tags=[
(tk.key, tv.value),
],
)
deletion = ScheduledDeletion.schedule(event, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert not Event.objects.filter(id=event.id).exists()
assert not EventAttachment.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventMapping.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not UserReport.objects.filter(
event_id=event.event_id,
project_id=project.id,
).exists()
assert not EventTag.objects.filter(event_id=event.id).exists()
def test_simple(self):
org = self.create_organization(
name='test',
)
org2 = self.create_organization(name='test2')
self.create_team(organization=org, name='test1')
self.create_team(organization=org, name='test2')
release = Release.objects.create(version='a' * 32, organization_id=org.id)
repo = Repository.objects.create(
organization_id=org.id,
name=org.name,
provider='dummy',
)
commit_author = CommitAuthor.objects.create(
organization_id=org.id,
name='foo',
email='*****@*****.**',
)
commit = Commit.objects.create(
repository_id=repo.id,
organization_id=org.id,
author=commit_author,
key='a' * 40,
)
pull_request = PullRequest.objects.create(
repository_id=repo.id,
organization_id=org.id,
author=commit_author,
key='b' * 40,
)
ReleaseCommit.objects.create(
organization_id=org.id,
release=release,
commit=commit,
order=0,
)
env = Environment.objects.create(organization_id=org.id, project_id=4, name='foo')
release_env = ReleaseEnvironment.objects.create(
organization_id=org.id, project_id=4, release_id=release.id, environment_id=env.id
)
external_issue = ExternalIssue.objects.create(
organization_id=org.id,
integration_id=5,
key='12345',
)
dashboard = Dashboard.objects.create(
organization_id=org.id,
title='The Dashboard',
created_by=self.user,
)
widget_1 = Widget.objects.create(
dashboard=dashboard,
order=1,
title='Widget 1',
display_type=0,
)
widget_2 = Widget.objects.create(
dashboard=dashboard,
order=2,
title='Widget 2',
display_type=5,
)
widget_1_data = WidgetDataSource.objects.create(
widget=widget_1,
order=1,
type=0,
name='Incoming data',
)
widget_2_data_1 = WidgetDataSource.objects.create(
widget=widget_2,
order=1,
type=0,
name='Incoming data',
)
widget_2_data_2 = WidgetDataSource.objects.create(
widget=widget_2,
order=2,
type=0,
name='Outcoming data',
)
deletion = ScheduledDeletion.schedule(org, days=0)
deletion.update(in_progress=True)
with self.tasks():
run_deletion(deletion.id)
assert Organization.objects.filter(id=org2.id).exists()
assert not Organization.objects.filter(id=org.id).exists()
assert not Environment.objects.filter(id=env.id).exists()
assert not ReleaseEnvironment.objects.filter(id=release_env.id).exists()
assert not Repository.objects.filter(id=repo.id).exists()
assert not ReleaseCommit.objects.filter(organization_id=org.id).exists()
assert not Release.objects.filter(organization_id=org.id).exists()
assert not CommitAuthor.objects.filter(id=commit_author.id).exists()
assert not Commit.objects.filter(id=commit.id).exists()
assert not PullRequest.objects.filter(id=pull_request.id).exists()
assert not ExternalIssue.objects.filter(id=external_issue.id).exists()
assert not Dashboard.objects.filter(id=dashboard.id).exists()
assert not Widget.objects.filter(id__in=[widget_1.id, widget_2.id]).exists()
assert not WidgetDataSource.objects.filter(
id__in=[
widget_1_data.id,
widget_2_data_1.id,
widget_2_data_2.id]).exists()
