test(backup): Add final model tests

tests/sentry/backup/test_models.py

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 import tempfile
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Type
+from uuid import uuid4
 
 from click.testing import CliRunner
 from django.core.management import call_command
 from django.utils import timezone
+from sentry_relay.auth import generate_key_pair
 
 from sentry.incidents.models import (
     AlertRule,
@@ -16,35 +18,64 @@
     AlertRuleTrigger,
     AlertRuleTriggerAction,
     AlertRuleTriggerExclusion,
+    PendingIncidentSnapshot,
+    TimeSeriesSnapshot,
 )
+from sentry.models.actor import ACTOR_TYPES, Actor
+from sentry.models.counter import Counter
 from sentry.models.dashboard import Dashboard, DashboardTombstone
 from sentry.models.dashboard_widget import (
     DashboardWidget,
     DashboardWidgetQuery,
     DashboardWidgetTypes,
 )
+from sentry.models.email import Email
 from sentry.models.environment import Environment, EnvironmentProject
+from sentry.models.integrations.sentry_app import SentryApp
+from sentry.models.integrations.sentry_app_component import SentryAppComponent
+from sentry.models.integrations.sentry_app_installation import SentryAppInstallation
+from sentry.models.notificationaction import NotificationAction, NotificationActionProject
+from sentry.models.options.option import ControlOption, Option
+from sentry.models.options.organization_option import OrganizationOption
 from sentry.models.options.project_option import ProjectOption
 from sentry.models.options.user_option import UserOption
 from sentry.models.organization import Organization
 from sentry.models.organizationaccessrequest import OrganizationAccessRequest
 from sentry.models.organizationmapping import OrganizationMapping
 from sentry.models.organizationmember import OrganizationMember
 from sentry.models.organizationmemberteam import OrganizationMemberTeam
+from sentry.models.orgauthtoken import OrgAuthToken
 from sentry.models.project import Project
 from sentry.models.projectbookmark import ProjectBookmark
 from sentry.models.projectkey import ProjectKey
 from sentry.models.projectownership import ProjectOwnership
 from sentry.models.projectredirect import ProjectRedirect
 from sentry.models.projectteam import ProjectTeam
+from sentry.models.recentsearch import RecentSearch
+from sentry.models.relay import Relay, RelayUsage
+from sentry.models.repository import Repository
+from sentry.models.rule import Rule, RuleActivity, RuleActivityType
+from sentry.models.rulesnooze import RuleSnooze
+from sentry.models.savedsearch import SavedSearch, Visibility
+from sentry.models.search_common import SearchType
+from sentry.models.servicehook import ServiceHook
 from sentry.models.team import Team
 from sentry.models.user import User
 from sentry.models.useremail import UserEmail
 from sentry.models.userip import UserIP
 from sentry.models.userpermission import UserPermission
 from sentry.models.userrole import UserRole, UserRoleUser
-from sentry.monitors.models import Monitor, MonitorEnvironment, MonitorType, ScheduleType
+from sentry.monitors.models import (
+    CheckInStatus,
+    Monitor,
+    MonitorCheckIn,
+    MonitorEnvironment,
+    MonitorLocation,
+    MonitorType,
+    ScheduleType,
+)
 from sentry.runner.commands.backup import import_, validate
+from sentry.sentry_apps.apps import SentryAppUpdater
 from sentry.silo import unguarded_write
 from sentry.snuba.models import QuerySubscription, SnubaQuery, SnubaQueryEventType
 from sentry.testutils import TransactionTestCase
@@ -161,6 +192,17 @@ def test_alert_rule_trigger(self):
         self.create_alert_rule_trigger_action(alert_rule_trigger=trigger)
         return self.import_export_then_validate()
 
+    @targets_models(ControlOption)
+    def test_control_option(self):
+        ControlOption.objects.create(key="foo", value="bar")
+        return self.import_export_then_validate()
+
+    @targets_models(Counter)
+    def test_counter(self):
+        project = self.create_project()
+        Counter.increment(project, 1)
+        return self.import_export_then_validate()
+
     @targets_models(Dashboard)
     def test_dashboard(self):
         self.create_dashboard()
@@ -184,6 +226,11 @@ def test_dashboard_widget(self):
         DashboardWidgetQuery.objects.create(widget=widget, order=1, name="Test Query")
         return self.import_export_then_validate()
 
+    @targets_models(Email)
+    def test_email(self):
+        Email.objects.create(email="[email protected]")
+        return self.import_export_then_validate()
+
     @targets_models(Environment)
     def test_environment(self):
         self.create_environment()
@@ -201,14 +248,46 @@ def test_monitor(self):
         self.create_monitor()
         return self.import_export_then_validate()
 
-    @targets_models(MonitorEnvironment)
+    @targets_models(MonitorEnvironment, MonitorLocation)
     def test_monitor_environment(self):
         monitor = self.create_monitor()
         env = Environment.objects.create(organization_id=monitor.organization_id, name="test_env")
-        MonitorEnvironment.objects.create(
+        mon_env = MonitorEnvironment.objects.create(
             monitor=monitor,
             environment=env,
         )
+        location = MonitorLocation.objects.create(guid=uuid4(), name="test_location")
+        MonitorCheckIn.objects.create(
+            monitor=monitor,
+            monitor_environment=mon_env,
+            location=location,
+            project_id=monitor.project_id,
+            status=CheckInStatus.IN_PROGRESS,
+        )
+        return self.import_export_then_validate()
+
+    @targets_models(NotificationAction, NotificationActionProject)
+    def test_notification_action(self):
+        self.create_notification_action(organization=self.organization, projects=[self.project])
+        return self.import_export_then_validate()
+
+    @targets_models(Option)
+    def test_option(self):
+        Option.objects.create(key="foo", value="bar")
+        return self.import_export_then_validate()
+
+    @targets_models(OrgAuthToken)
+    def test_org_auth_token(self):
+        user = self.create_user()
+        org = self.create_organization(owner=user)
+        OrgAuthToken.objects.create(
+            organization_id=org.id,
+            name="token 1",
+            token_hashed="ABCDEF",
+            token_last_characters="xyz1",
+            scope_list=["org:ci"],
+            date_last_used=None,
+        )
         return self.import_export_then_validate()
 
     @targets_models(Organization, OrganizationMapping)
@@ -228,6 +307,14 @@ def test_organization_membership(self):
         OrganizationAccessRequest.objects.create(member=member, team=team)
         return self.import_export_then_validate()
 
+    @targets_models(OrganizationOption)
+    def test_organization_option(self):
+        organization = self.create_organization(name="test_org", owner=self.user)
+        OrganizationOption.objects.create(
+            organization=organization, key="sentry:account-rate-limit", value=0
+        )
+        return self.import_export_then_validate()
+
     @targets_models(Project, ProjectKey, ProjectOption, ProjectTeam)
     def test_project(self):
         self.create_project()
@@ -260,6 +347,87 @@ def test_project_redirect(self):
         ProjectRedirect.record(project, "old_slug")
         return self.import_export_then_validate()
 
+    @targets_models(Relay, RelayUsage)
+    def test_relay(self):
+        _, public_key = generate_key_pair()
+        relay_id = str(uuid4())
+        Relay.objects.create(relay_id=relay_id, public_key=str(public_key), is_internal=True)
+        RelayUsage.objects.create(relay_id=relay_id, version="0.0.1", public_key=public_key)
+        return self.import_export_then_validate()
+
+    @targets_models(Repository)
+    def test_repository(self):
+        Repository.objects.create(
+            name="test_repo",
+            organization_id=self.organization.id,
+            integration_id=self.integration.id,
+        )
+        return self.import_export_then_validate()
+
+    @targets_models(Rule, RuleActivity, RuleSnooze)
+    def test_rule(self):
+        rule = self.create_project_rule(project=self.project)
+        RuleActivity.objects.create(rule=rule, type=RuleActivityType.CREATED.value)
+        self.snooze_rule(user_id=self.user.id, owner_id=self.user.id, rule=rule)
+        return self.import_export_then_validate()
+
+    @targets_models(RecentSearch, SavedSearch)
+    def test_search(self):
+        RecentSearch.objects.create(
+            organization=self.organization,
+            user_id=self.user.id,
+            type=SearchType.ISSUE.value,
+            query="some query",
+        )
+        SavedSearch.objects.create(
+            organization=self.organization,
+            name="Saved query",
+            query="saved query",
+            visibility=Visibility.ORGANIZATION,
+        )
+        return self.import_export_then_validate()
+
+    @targets_models(SentryApp, SentryAppComponent, SentryAppInstallation)
+    def test_sentry_app(self):
+        app = self.create_sentry_app(name="test_app", organization=self.organization)
+        self.create_sentry_app_installation(
+            slug=app.slug, organization=self.organization, user=self.user
+        )
+        updater = SentryAppUpdater(sentry_app=app)
+        updater.schema = {"elements": [self.create_alert_rule_action_schema()]}
+        updater.run(self.user)
+        return self.import_export_then_validate()
+
+    @targets_models(PendingIncidentSnapshot, TimeSeriesSnapshot)
+    def test_snapshot(self):
+        incident = self.create_incident()
+        PendingIncidentSnapshot.objects.create(
+            incident=incident, target_run_date=datetime.utcnow() + timedelta(hours=4)
+        )
+        TimeSeriesSnapshot.objects.create(
+            start=datetime.utcnow() - timedelta(hours=24),
+            end=datetime.utcnow(),
+            values=[[1.0, 2.0, 3.0], [1.5, 2.5, 3.5]],
+            period=1,
+        )
+        return self.import_export_then_validate()
+
+    @targets_models(ServiceHook)
+    def test_service_hook(self):
+        app = self.create_sentry_app()
+        actor = Actor.objects.create(type=ACTOR_TYPES["team"])
+        install = self.create_sentry_app_installation(organization=self.organization, slug=app.slug)
+        ServiceHook.objects.create(
+            application_id=app.id,
+            actor_id=actor.id,
+            project_id=self.project.id,
+            organization_id=self.organization.id,
+            events=[],
+            installation_id=install.id,
+            url="https://example.com",
+        )
+        return self.import_export_then_validate()
+
     @targets_models(User, UserEmail, UserOption, UserPermission)
     def test_user(self):
         user = self.create_user()