def delete(self, request, organization, integration_id):
# Removing the integration removes the organization
# integrations and all linked issues.
org_integration = self.get_organization_integration(
organization, integration_id)
integration = org_integration.integration
# do any integration specific deleting steps
integration.get_installation(organization.id).uninstall()
with transaction.atomic():
updated = OrganizationIntegration.objects.filter(
id=org_integration.id, status=ObjectStatus.VISIBLE).update(
status=ObjectStatus.PENDING_DELETION)
if updated:
ScheduledDeletion.schedule(org_integration,
days=0,
actor=request.user)
create_audit_entry(
request=request,
organization=organization,
target_object=integration.id,
event=AuditLogEntryEvent.INTEGRATION_REMOVE,
data={
"provider": integration.provider,
"name": integration.name
},
)
return self.respond(status=204)
def delete_initializing_orgs(**kwargs):
"""
Deletes orgs that are still in the initializing state.
This happens if Sentry is killed while an organization is being created.
"""
if not settings.DEMO_MODE:
return
logger.info("delete_initializing_orgs.start")
# delete everything older than MAX_INITIALIZATION_TIME
max_init_time = settings.DEMO_DATA_GEN_PARAMS["MAX_INITIALIZATION_TIME"]
cutoff_time = timezone.now() - timedelta(minutes=max_init_time)
# note this only runs in demo mode (not SaaS) so the underlying tables here are small
org_list = Organization.objects.filter(
demoorganization__date_added__lte=cutoff_time,
demoorganization__status=DemoOrgStatus.INITIALIZING,
)
# first mark orgs for deletion
org_list.update(status=OrganizationStatus.PENDING_DELETION)
# now finally delete the orgs
for org in org_list:
# apply async so if so we continue if one org aborts
logger.info("delete_initializing_orgs.delete",
extra={"organization_slug": org.slug})
ScheduledDeletion.schedule(org, days=0)
# build up the org buffer at the end to replace the orgs being removed
build_up_org_buffer()
def delete_users_orgs(**kwargs):
if not settings.DEMO_MODE:
return
logger.info("delete_users_orgs.start")
# delete everything older than a day
cutoff_time = timezone.now() - timedelta(days=1)
# note this only runs in demo mode (not SaaS) so the underlying tables here are small
org_list = Organization.objects.filter(
demoorganization__date_assigned__lte=cutoff_time,
demoorganization__status=DemoOrgStatus.ACTIVE,
status__in=(
OrganizationStatus.ACTIVE,
OrganizationStatus.PENDING_DELETION,
),
)
# first mark orgs for deletion
org_list.update(status=OrganizationStatus.PENDING_DELETION)
# next delete the users
User.objects.filter(demouser__isnull=False,
demouser__date_assigned__lte=cutoff_time).delete()
# now finally delete the orgs
for org in org_list:
# apply async so if so we continue if one org aborts
logger.info("delete_initializing_orgs.delete",
extra={"organization_slug": org.slug})
ScheduledDeletion.schedule(org, days=0)
def delete(self, request, organization, repo_id):
if not request.user.is_authenticated:
return Response(status=401)
try:
repo = Repository.objects.get(id=repo_id, organization_id=organization.id)
except Repository.DoesNotExist:
raise ResourceDoesNotExist
with transaction.atomic():
updated = Repository.objects.filter(
id=repo.id, status__in=[ObjectStatus.VISIBLE, ObjectStatus.DISABLED]
).update(status=ObjectStatus.PENDING_DELETION)
if updated:
repo.status = ObjectStatus.PENDING_DELETION
# if repo doesn't have commits, delete immediately
has_commits = Commit.objects.filter(
repository_id=repo.id, organization_id=organization.id
).exists()
repo.rename_on_pending_deletion()
if has_commits:
ScheduledDeletion.schedule(repo, days=0, hours=1, actor=request.user)
else:
ScheduledDeletion.schedule(repo, days=0, actor=request.user)
return Response(serialize(repo, request.user), status=202)
def test_cancel_delete(self):
org = self.create_organization(
owner=self.user, status=OrganizationStatus.PENDING_DELETION)
ScheduledDeletion.schedule(org, days=1)
self.get_success_response(org.slug, **{"cancelDeletion": True})
org = Organization.objects.get(id=org.id)
assert org.status == OrganizationStatus.VISIBLE
assert not ScheduledDeletion.objects.filter(model_name="Organization",
object_id=org.id).exists()
def test_duplicate_schedule(self):
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
first = ScheduledDeletion.schedule(team, days=0)
second = ScheduledDeletion.schedule(team, days=1)
# Should get the same record.
assert first.id == second.id
assert first.guid == second.guid
# Date should be updated
assert second.date_scheduled - first.date_scheduled >= timedelta(days=1)
def test_redo_deletion(self):
# Orgs can delete, undelete, delete within a day
org = self.create_organization(owner=self.user)
ScheduledDeletion.schedule(org, days=1)
self.get_success_response(org.slug)
org = Organization.objects.get(id=org.id)
assert org.status == OrganizationStatus.PENDING_DELETION
assert ScheduledDeletion.objects.filter(
object_id=org.id, model_name="Organization").exists()
def test_no_pending_delete_trigger_on_skipped_delete(self):
org = self.create_organization(name="test")
project = self.create_project(organization=org)
repo = self.create_repo(project=project, name="example/example")
signal_handler = Mock()
pending_delete.connect(signal_handler)
ScheduledDeletion.schedule(instance=repo, actor=self.user, days=0)
with self.tasks():
run_scheduled_deletions()
pending_delete.disconnect(signal_handler)
assert signal_handler.call_count == 0
def delete(self, request: Request, app_id) -> Response:
try:
instance = ApiApplication.objects.get(
owner=request.user, client_id=app_id, status=ApiApplicationStatus.active
)
except ApiApplication.DoesNotExist:
raise ResourceDoesNotExist
with transaction.atomic():
updated = ApiApplication.objects.filter(id=instance.id).update(
status=ApiApplicationStatus.pending_deletion
)
if updated:
ScheduledDeletion.schedule(instance, days=0, actor=request.user)
return Response(status=204)
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()
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 delete(self, request: Request, team) -> Response:
"""
Delete a Team
`````````````
Schedules a team for deletion.
**Note:** Deletion happens asynchronously and therefore is not
immediate. Teams will have their slug released while waiting for deletion.
"""
suffix = uuid4().hex
new_slug = f"{team.slug}-{suffix}"[0:50]
updated = Team.objects.filter(id=team.id, status=TeamStatus.VISIBLE).update(
slug=new_slug, status=TeamStatus.PENDING_DELETION
)
if updated:
scheduled = ScheduledDeletion.schedule(team, days=0, actor=request.user)
self.create_audit_entry(
request=request,
organization=team.organization,
target_object=team.id,
event=AuditLogEntryEvent.TEAM_REMOVE,
data=team.get_audit_log_data(),
transaction_id=scheduled.id,
)
return Response(status=204)
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 delete(self, request, project, monitor):
"""
Delete a monitor
````````````````
:pparam string monitor_id: the id of the monitor.
:auth: required
"""
with transaction.atomic():
affected = (Monitor.objects.filter(id=monitor.id).exclude(
status__in=[
MonitorStatus.PENDING_DELETION,
MonitorStatus.DELETION_IN_PROGRESS
]).update(status=MonitorStatus.PENDING_DELETION))
if not affected:
return self.respond(status=404)
schedule = ScheduledDeletion.schedule(monitor,
days=0,
actor=request.user)
self.create_audit_entry(
request=request,
organization=project.organization,
target_object=monitor.id,
event=AuditLogEntryEvent.MONITOR_REMOVE,
data=monitor.get_audit_log_data(),
transaction_id=schedule.guid,
)
return self.respond(status=202)
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):
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_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_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 handle_delete(self, request, organization):
"""
This method exists as a way for getsentry to override this endpoint with less duplication.
"""
if not request.user.is_authenticated:
return self.respond({"detail": ERR_NO_USER}, status=401)
if organization.is_default:
return self.respond({"detail": ERR_DEFAULT_ORG}, status=400)
with transaction.atomic():
updated = Organization.objects.filter(
id=organization.id, status=OrganizationStatus.VISIBLE).update(
status=OrganizationStatus.PENDING_DELETION)
if updated:
organization.status = OrganizationStatus.PENDING_DELETION
schedule = ScheduledDeletion.schedule(organization,
days=1,
actor=request.user)
entry = self.create_audit_entry(
request=request,
organization=organization,
target_object=organization.id,
event=AuditLogEntryEvent.ORG_REMOVE,
data=organization.get_audit_log_data(),
transaction_id=schedule.guid,
)
organization.send_delete_confirmation(entry, ONE_DAY)
context = serialize(
organization,
request.user,
org_serializers.DetailedOrganizationSerializerWithProjectsAndTeams(
),
access=request.access,
)
return self.respond(context, status=202)
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_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_triggers_pending_delete_signal(self):
signal_handler = Mock()
pending_delete.connect(signal_handler)
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
ScheduledDeletion.schedule(instance=team, actor=self.user, days=0)
with self.tasks():
run_scheduled_deletions()
assert signal_handler.call_count == 1
args = signal_handler.call_args_list[0][1]
assert args["instance"] == team
assert args["actor"] == self.user
pending_delete.disconnect(signal_handler)
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_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):
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_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_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):
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
schedule = ScheduledDeletion.schedule(instance=team, days=0)
with self.tasks():
run_scheduled_deletions()
assert not Team.objects.filter(id=team.id).exists()
assert not ScheduledDeletion.objects.filter(id=schedule.id).exists()
def test_schedule_and_cancel(self):
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
schedule = ScheduledDeletion.schedule(team, days=0)
ScheduledDeletion.cancel(team)
assert not ScheduledDeletion.objects.filter(id=schedule.id).exists()
# No errors if we cancel a delete that wasn't started.
assert ScheduledDeletion.cancel(team) is None
def test_ignore_recent_jobs(self):
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
schedule = ScheduledDeletion.schedule(instance=team, days=0)
schedule.update(in_progress=True)
with self.tasks():
reattempt_deletions()
schedule.refresh_from_db()
assert schedule.in_progress is True
def test_future_schedule(self):
org = self.create_organization(name="test")
team = self.create_team(organization=org, name="delete")
schedule = ScheduledDeletion.schedule(instance=team, days=1)
with self.tasks():
run_scheduled_deletions()
assert Team.objects.filter(id=team.id).exists()
assert ScheduledDeletion.objects.filter(id=schedule.id, in_progress=False).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_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,
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):
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):
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_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(
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):
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()
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()
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()
