ref: Remove unused Group.get_oldest_event and legacy events behavior

Removes the "snuba.events-queries.enabled" option and legacy code paths
that were not being used in production. Also removes the unused
Group.get_oldest_event method. Part 4 of #13905

Author: lynnagara

src/sentry/models/group.py

@@ -20,7 +20,7 @@
 from django.utils.http import urlencode
 from django.utils.translation import ugettext_lazy as _
 
-from sentry import eventtypes, tagstore, options
+from sentry import eventtypes, tagstore
 from sentry.constants import (
     DEFAULT_LOGGER_NAME, EVENT_ORDERING_KEY, LOG_LEVELS, MAX_CULPRIT_LENGTH
 )
@@ -393,41 +393,13 @@ def get_latest_event(self):
         return self._latest_event
 
     def get_latest_event_for_environments(self, environments=()):
-        use_snuba = options.get('snuba.events-queries.enabled')
-
-        # Fetch without environment if Snuba is not enabled
-        if not use_snuba:
-            return self.get_latest_event()
-
         return get_oldest_or_latest_event_for_environments(
             EventOrdering.LATEST,
             environments=environments,
             issue_id=self.id,
             project_id=self.project_id)
 
-    def get_oldest_event(self):
-        from sentry.models import Event
-
-        if not hasattr(self, '_oldest_event'):
-            oldest_events = sorted(
-                Event.objects.filter(
-                    group_id=self.id,
-                ).order_by('datetime')[0:5],
-                key=EVENT_ORDERING_KEY,
-            )
-            try:
-                self._oldest_event = oldest_events[0]
-            except IndexError:
-                self._oldest_event = None
-        return self._oldest_event
-
     def get_oldest_event_for_environments(self, environments=()):
-        use_snuba = options.get('snuba.events-queries.enabled')
-
-        # Fetch without environment if Snuba is not enabled
-        if not use_snuba:
-            return self.get_oldest_event()
-
         return get_oldest_or_latest_event_for_environments(
             EventOrdering.OLDEST,
             environments=environments,

tests/sentry/models/test_group.py

@@ -1,8 +1,6 @@
 from __future__ import absolute_import
 
-import six
-
-from datetime import datetime, timedelta
+from datetime import timedelta
 
 import pytest
 from django.db.models import ProtectedError
@@ -16,6 +14,13 @@
 
 
 class GroupTest(TestCase):
+    def setUp(self):
+        super(GroupTest, self).setUp()
+        self.min_ago = (timezone.now() - timedelta(minutes=1)).isoformat()[:19]
+        self.two_min_ago = (timezone.now() - timedelta(minutes=2)).isoformat()[:19]
+        self.sec_ago = (timezone.now() - timedelta(seconds=1)).isoformat()[:19]
+        self.two_sec_ago = (timezone.now() - timedelta(seconds=1)).isoformat()[:19]
+
     def test_is_resolved(self):
         group = self.create_group(status=GroupStatus.RESOLVED)
         assert group.is_resolved()
@@ -36,56 +41,68 @@ def test_is_resolved(self):
 
         assert group.is_resolved()
 
-    def test_get_oldest_latest_event_no_events(self):
-        group = self.create_group()
+    def test_get_latest_event_no_events(self):
+        project = self.create_project()
+        group = self.create_group(project=project)
         assert group.get_latest_event() is None
-        assert group.get_oldest_event() is None
 
-    def test_get_oldest_latest_events(self):
-        group = self.create_group()
-        for i in range(0, 3):
-            self.create_event(
-                event_id=six.text_type(i),
-                group=group,
-                datetime=datetime(2013, 8, 13, 3, 8, i),
-            )
-
-        assert group.get_latest_event().event_id == '2'
-        assert group.get_oldest_event().event_id == '0'
+    def test_get_latest_event(self):
+        self.store_event(
+            data={
+                'event_id': 'a' * 32,
+                'fingerprint': ['group-1'],
+                'timestamp': self.two_min_ago,
+            },
+            project_id=self.project.id,
+        )
+        self.store_event(
+            data={
+                'event_id': 'b' * 32,
+                'fingerprint': ['group-1'],
+                'timestamp': self.min_ago,
+            },
+            project_id=self.project.id,
+        )
 
-    def test_get_oldest_latest_identical_timestamps(self):
-        group = self.create_group()
-        for i in range(0, 3):
-            self.create_event(
-                event_id=six.text_type(i),
-                group=group,
-                datetime=datetime(2013, 8, 13, 3, 8, 50),
-            )
+        group = Group.objects.first()
 
-        assert group.get_latest_event().event_id == '2'
-        assert group.get_oldest_event().event_id == '0'
+        assert group.get_latest_event().event_id == 'b' * 32
 
-    def test_get_oldest_latest_almost_identical_timestamps(self):
-        group = self.create_group()
-        self.create_event(
-            event_id='0',
-            group=group,
-            datetime=datetime(2013, 8, 13, 3, 8, 0),  # earliest
-        )
-        for i in range(1, 3):
-            self.create_event(
-                event_id=six.text_type(i),
-                group=group,
-                datetime=datetime(2013, 8, 13, 3, 8, 30),  # all in the middle
+    def test_get_latest_identical_timestamps(self):
+        events = []
+        for i in 'abc':
+            event = self.store_event(
+                data={
+                    'event_id': i * 32,
+                    'fingerprint': ['group-1'],
+                    'timestamp': self.min_ago,
+                },
+                project_id=self.project.id,
             )
-        self.create_event(
-            event_id='3',
-            group=group,
-            datetime=datetime(2013, 8, 13, 3, 8, 59),  # latest
+            events.append(event)
+
+        assert events[0].group.get_latest_event().event_id == 'c' * 32
+
+    def test_get_latest_almost_identical_timestamps(self):
+        self.store_event(
+            data={
+                'event_id': 'a' * 32,
+                'fingerprint': ['group-1'],
+                'timestamp': self.two_sec_ago,
+            },
+            project_id=self.project.id,
+        )
+        self.store_event(
+            data={
+                'event_id': 'b' * 32,
+                'fingerprint': ['group-1'],
+                'timestamp': self.sec_ago,
+            },
+            project_id=self.project.id,
         )
+        group = Group.objects.first()
 
-        assert group.get_latest_event().event_id == '3'
-        assert group.get_oldest_event().event_id == '0'
+        assert group.get_latest_event().event_id == 'b' * 32
 
     def test_is_ignored_with_expired_snooze(self):
         group = self.create_group(