test: Rewrite tests to use store_event instead of create_event (#16212)

src/sentry/testutils/fixtures.py

@@ -8,6 +8,7 @@ from sentry.incidents.models import IncidentActivityType
 import pytest
 from django.utils.functional import cached_property
 from sentry.testutils.factories import Factories
+from sentry.testutils.helpers.datetime import before_now, iso_format
 
 
 # XXX(dcramer): this is a compatibility layer to transition to pytest-based fixtures
@@ -61,7 +62,14 @@ class Fixtures(object):
 
     @cached_property
     def event(self):
-        return self.create_event(event_id="a" * 32, message="\u3053\u3093\u306b\u3061\u306f")
+        return self.store_event(
+            data={
+                "event_id": "a" * 32,
+                "message": "\u3053\u3093\u306b\u3061\u306f",
+                "timestamp": iso_format(before_now(seconds=1)),
+            },
+            project_id=self.project.id,
+        )
 
     @cached_property
     def activity(self):
@@ -145,9 +153,6 @@ class Fixtures(object):
             group = self.group
         return Factories.create_event(event_id=event_id, group=group, *args, **kwargs)
 
-    def create_issueless_event(self, event_id=None, *args, **kwargs):
-        return Factories.create_event(event_id=event_id, group=None, *args, **kwargs)
-
     def store_event(self, *args, **kwargs):
         return Factories.store_event(*args, **kwargs)
 

tests/sentry/api/endpoints/test_group_user_reports.py

@@ -1,20 +1,22 @@
 from __future__ import absolute_import
 from exam import fixture
 
-from sentry.models import Environment, GroupStatus, UserReport
+from sentry.models import Environment, UserReport
 from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import before_now, iso_format
 
 
 class GroupUserReport(APITestCase, SnubaTestCase):
     def setUp(self):
+        super(GroupUserReport, self).setUp()
         self.project = self.create_project()
         self.env1 = self.create_environment(self.project, "production")
         self.env2 = self.create_environment(self.project, "staging")
 
-        self.group = self.create_group(project=self.project, status=GroupStatus.UNRESOLVED)
+        self.env1_events = self.create_events_for_environment(self.env1, 5)
+        self.env2_events = self.create_events_for_environment(self.env2, 5)
 
-        self.env1_events = self.create_events_for_environment(self.group, self.env1, 5)
-        self.env2_events = self.create_events_for_environment(self.group, self.env2, 5)
+        self.group = self.env1_events[0].group
 
         self.env1_userreports = self.create_user_report_for_events(
             self.project, self.group, self.env1_events, self.env1
@@ -34,9 +36,16 @@ class GroupUserReport(APITestCase, SnubaTestCase):
         env.add_project(project)
         return env
 
-    def create_events_for_environment(self, group, environment, num_events):
+    def create_events_for_environment(self, environment, num_events):
         return [
-            self.create_event(group=group, tags={"environment": environment.name})
+            self.store_event(
+                data={
+                    "fingerprint": ["group-1"],
+                    "tags": {"environment": environment.name},
+                    "timestamp": iso_format(before_now(seconds=1)),
+                },
+                project_id=self.project.id,
+            )
             for __i in range(num_events)
         ]
 
@@ -85,7 +94,7 @@ class GroupUserReport(APITestCase, SnubaTestCase):
         self.login_as(user=self.user)
 
         empty_env = self.create_environment(self.project, u"")
-        empty_env_events = self.create_events_for_environment(self.group, empty_env, 5)
+        empty_env_events = self.create_events_for_environment(empty_env, 5)
         userreports = self.create_user_report_for_events(
             self.project, self.group, empty_env_events, empty_env
         )

tests/sentry/deletions/test_project.py

@@ -25,8 +25,8 @@ from sentry.testutils import TestCase
 class DeleteProjectTest(TestCase):
     def test_simple(self):
         project = self.create_project(name="test")
-        group = self.create_group(project=project)
-        event = self.create_event(group=group)
+        event = self.store_event(data={}, project_id=project.id)
+        group = event.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)

tests/sentry/digests/test_notifications.py

@@ -64,13 +64,17 @@ class GroupRecordsTestCase(TestCase):
         return self.project.rule_set.all()[0]
 
     def test_success(self):
-        events = [self.create_event(group=self.group) for _ in range(3)]
+        events = [
+            self.store_event(data={"fingerprint": ["group-1"]}, project_id=self.project.id)
+            for i in range(3)
+        ]
+        group = events[0].group
         records = [
             Record(event.event_id, Notification(event, [self.rule]), event.datetime)
             for event in events
         ]
         assert reduce(group_records, records, defaultdict(lambda: defaultdict(list))) == {
-            self.rule: {self.group: records}
+            self.rule: {group: records}
         }
 
 

tests/sentry/eventstore/test_models.py

@@ -121,41 +121,46 @@ class EventTest(TestCase):
             event.get_environment() == environment
 
     def test_ip_address(self):
-        event = self.create_event(
+        event = self.store_event(
             data={
                 "user": {"ip_address": "127.0.0.1"},
                 "request": {"url": "http://some.com", "env": {"REMOTE_ADDR": "::1"}},
-            }
+            },
+            project_id=self.project.id,
         )
         assert event.ip_address == "127.0.0.1"
 
-        event = self.create_event(
+        event = self.store_event(
             data={
                 "user": {"ip_address": None},
                 "request": {"url": "http://some.com", "env": {"REMOTE_ADDR": "::1"}},
-            }
+            },
+            project_id=self.project.id,
         )
         assert event.ip_address == "::1"
 
-        event = self.create_event(
+        event = self.store_event(
             data={
                 "user": None,
                 "request": {"url": "http://some.com", "env": {"REMOTE_ADDR": "::1"}},
-            }
+            },
+            project_id=self.project.id,
         )
         assert event.ip_address == "::1"
 
-        event = self.create_event(
-            data={"request": {"url": "http://some.com", "env": {"REMOTE_ADDR": "::1"}}}
+        event = self.store_event(
+            data={"request": {"url": "http://some.com", "env": {"REMOTE_ADDR": "::1"}}},
+            project_id=self.project.id,
         )
         assert event.ip_address == "::1"
 
-        event = self.create_event(
-            data={"request": {"url": "http://some.com", "env": {"REMOTE_ADDR": None}}}
+        event = self.store_event(
+            data={"request": {"url": "http://some.com", "env": {"REMOTE_ADDR": None}}},
+            project_id=self.project.id,
         )
         assert event.ip_address is None
 
-        event = self.create_event()
+        event = self.store_event(data={}, project_id=self.project.id)
         assert event.ip_address is None
 
     def test_issueless_event(self):

tests/sentry/integrations/slack/test_utils.py

@@ -164,10 +164,10 @@ class BuildIncidentAttachmentTest(TestCase):
             "fallback": u"[{}] {}".format(self.project.slug, group.title),
             "footer_icon": u"http://testserver/_static/{version}/sentry/images/sentry-email-avatar.png",
         }
-        event = self.create_event()
+        event = self.store_event(data={}, project_id=self.project.id)
         ts = event.datetime
         assert build_group_attachment(group, event) == {
-            "color": "error",
+            "color": "#E03E2F",
             "text": "",
             "actions": [
                 {"name": "status", "text": "Resolve", "type": "button", "value": "resolved"},

tests/sentry/models/tests.py

@@ -139,11 +139,11 @@ class EventNodeStoreTest(TestCase):
             event.bind_node_data()
 
     def test_accepts_valid_ref(self):
-        event = self.create_event()
+        event = self.store_event(data={}, project_id=self.project.id)
         event.data.bind_ref(event)
         event.bind_node_data()
         assert event.data.ref == event.project.id
 
     def test_basic_ref_binding(self):
-        event = self.create_event()
+        event = self.store_event(data={}, project_id=self.project.id)
         assert event.data.get_ref(event) == event.project.id

tests/sentry/plugins/bases/notify/tests.py

@@ -42,7 +42,7 @@ class NotifyPlugin(TestCase):
             def hook(*a, **kw):
                 raise err
 
-            event = self.create_event()
+            event = self.store_event(data={}, project_id=self.project.id)
             notification = Notification(event)
 
             n.notify_users = hook

tests/sentry/plugins/mail/tests.py

@@ -22,7 +22,9 @@ from sentry.models import (
     Organization,
     OrganizationMember,
     OrganizationMemberTeam,
+    ProjectOption,
     ProjectOwnership,
+    Repository,
     Rule,
     UserOption,
     UserOptionValue,
@@ -35,6 +37,7 @@ from sentry.plugins.sentry_mail.models import MailPlugin
 from sentry.testutils import TestCase
 from sentry.utils.email import MessageBuilder
 from sentry.event_manager import EventManager
+from sentry.testutils.helpers.datetime import before_now, iso_format
 
 
 class MailPluginTest(TestCase):
@@ -77,11 +80,8 @@ class MailPluginTest(TestCase):
         _get_title.return_value = "Stacktrace"
 
         event = self.store_event(
-            data={
-                "message": "Soubor ji\xc5\xbe existuje",
-                "stacktrace": {"frames": [{}]}
-            },
-            project_id=self.project.id
+            data={"message": "Soubor ji\xc5\xbe existuje", "stacktrace": {"frames": [{}]}},
+            project_id=self.project.id,
         )
 
         notification = Notification(event=event)
@@ -210,14 +210,19 @@ class MailPluginTest(TestCase):
 
     @mock.patch.object(MailPlugin, "notify", side_effect=MailPlugin.notify, autospec=True)
     def test_notify_digest(self, notify):
-        project = self.event.project
+        project = self.project
+        event = self.store_event(
+            data={"timestamp": iso_format(before_now(minutes=1)), "fingerprint": ["group-1"]},
+            project_id=project.id,
+        )
+        event2 = self.store_event(
+            data={"timestamp": iso_format(before_now(minutes=1)), "fingerprint": ["group-2"]},
+            project_id=project.id,
+        )
+
         rule = project.rule_set.all()[0]
         digest = build_digest(
-            project,
-            (
-                event_to_record(self.create_event(group=self.create_group()), (rule,)),
-                event_to_record(self.event, (rule,)),
-            ),
+            project, (event_to_record(event, (rule,)), event_to_record(event2, (rule,)))
         )
 
         with self.tasks():
@@ -232,34 +237,34 @@ class MailPluginTest(TestCase):
     @mock.patch.object(MailPlugin, "notify", side_effect=MailPlugin.notify, autospec=True)
     @mock.patch.object(MessageBuilder, "send_async", autospec=True)
     def test_notify_digest_single_record(self, send_async, notify):
-        project = self.event.project
-        rule = project.rule_set.all()[0]
-        digest = build_digest(project, (event_to_record(self.event, (rule,)),))
-        self.plugin.notify_digest(project, digest)
+        event = self.store_event(data={}, project_id=self.project.id)
+        rule = self.project.rule_set.all()[0]
+        digest = build_digest(self.project, (event_to_record(event, (rule,)),))
+        self.plugin.notify_digest(self.project, digest)
         assert send_async.call_count == 1
         assert notify.call_count == 1
 
-    @mock.patch(
-        "sentry.models.ProjectOption.objects.get_value",
-        Mock(
-            side_effect=lambda p, k, d, **kw: "[Example prefix] "
-            if k == "mail:subject_prefix"
-            else d
-        ),
-    )
     def test_notify_digest_subject_prefix(self):
-        project = self.event.project
-        rule = project.rule_set.all()[0]
+        ProjectOption.objects.set_value(
+            project=self.project, key=u"mail:subject_prefix", value="[Example prefix] "
+        )
+        event = self.store_event(
+            data={"timestamp": iso_format(before_now(minutes=1)), "fingerprint": ["group-1"]},
+            project_id=self.project.id,
+        )
+        event2 = self.store_event(
+            data={"timestamp": iso_format(before_now(minutes=1)), "fingerprint": ["group-2"]},
+            project_id=self.project.id,
+        )
+
+        rule = self.project.rule_set.all()[0]
+
         digest = build_digest(
-            project,
-            (
-                event_to_record(self.create_event(group=self.create_group()), (rule,)),
-                event_to_record(self.event, (rule,)),
-            ),
+            self.project, (event_to_record(event, (rule,)), event_to_record(event2, (rule,)))
         )
 
         with self.tasks():
-            self.plugin.notify_digest(project, digest)
+            self.plugin.notify_digest(self.project, digest)
 
         assert len(mail.outbox) == 1
 
@@ -348,15 +353,56 @@ class MailPluginTest(TestCase):
         assert msg.to == [self.user.email]
 
     def test_notify_with_suspect_commits(self):
-        release = self.create_release(project=self.project, user=self.user)
-        group = self.create_group(project=self.project, first_release=release)
-        event = self.create_event(group=group, tags={"sentry:release": release.version})
+        repo = Repository.objects.create(
+            organization_id=self.organization.id, name=self.organization.id
+        )
+        release = self.create_release(project=self.project, version="v12")
+        release.set_commits(
+            [
+                {
+                    "id": "a" * 40,
+                    "repository": repo.name,
+                    "author_email": "bob@example.com",
+                    "author_name": "Bob",
+                    "message": "i fixed a bug",
+                    "patch_set": [{"path": "src/sentry/models/release.py", "type": "M"}],
+                }
+            ]
+        )
 
-        notification = Notification(event=event)
+        event = self.store_event(
+            data={
+                "message": "Kaboom!",
+                "platform": "python",
+                "timestamp": iso_format(before_now(seconds=1)),
+                "stacktrace": {
+                    "frames": [
+                        {
+                            "function": "handle_set_commits",
+                            "abs_path": "/usr/src/sentry/src/sentry/tasks.py",
+                            "module": "sentry.tasks",
+                            "in_app": True,
+                            "lineno": 30,
+                            "filename": "sentry/tasks.py",
+                        },
+                        {
+                            "function": "set_commits",
+                            "abs_path": "/usr/src/sentry/src/sentry/models/release.py",
+                            "module": "sentry.models.release",
+                            "in_app": True,
+                            "lineno": 39,
+                            "filename": "sentry/models/release.py",
+                        },
+                    ]
+                },
+                "tags": {"sentry:release": release.version},
+            },
+            project_id=self.project.id,
+        )
+
+        with self.tasks():
+            notification = Notification(event=event)
 
-        with self.tasks(), self.options({"system.url-prefix": "http://example.com"}), self.feature(
-            "organizations:suggested-commits"
-        ):
             self.plugin.notify(notification)
 
         assert len(mail.outbox) >= 1

tests/sentry/plugins/sentry_webhooks/test_plugin.py

@@ -23,8 +23,9 @@ class WebHooksPluginTest(TestCase):
     @responses.activate
     def test_simple_notification(self):
         responses.add(responses.POST, "http://example.com")
-        group = self.create_group(message="Hello world")
-        event = self.create_event(group=group, message="Hello world", tags={"level": "warning"})
+        event = self.store_event(
+            data={"message": "Hello world", "level": "warning"}, project_id=self.project.id
+        )
         rule = Rule.objects.create(project=self.project, label="my rule")
         notification = Notification(event=event, rule=rule)
         self.project.update_option("webhooks:urls", "http://example.com")