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()