test(tagstore): Run tests with SnubaCompatibilityTagStorage backend (#14778)

This is the first step to removing the LegacyTagStorage tagstore backend. We do not use this backend anymore except for running tests, and it will not work properly when we deprecate the Postgres events table.

src/sentry/conf/server.py

@@ -1056,7 +1056,9 @@ _SENTRY_TAGSTORE_DEFAULT_MULTI_OPTIONS = {
     "backends": [("sentry.tagstore.legacy.LegacyTagStorage", {})],
     "runner": "ImmediateRunner",
 }
-SENTRY_TAGSTORE = os.environ.get("SENTRY_TAGSTORE", "sentry.tagstore.legacy.LegacyTagStorage")
+SENTRY_TAGSTORE = os.environ.get(
+    "SENTRY_TAGSTORE", "sentry.tagstore.snuba.SnubaCompatibilityTagStorage"
+)
 SENTRY_TAGSTORE_OPTIONS = (
     _SENTRY_TAGSTORE_DEFAULT_MULTI_OPTIONS
     if "SENTRY_TAGSTORE_DEFAULT_MULTI_OPTIONS" in os.environ

src/sentry/utils/pytest/sentry.py

@@ -100,7 +100,6 @@ def pytest_configure(config):
 
     if os.environ.get("USE_SNUBA", False):
         settings.SENTRY_SEARCH = "sentry.search.snuba.SnubaSearchBackend"
-        settings.SENTRY_TAGSTORE = "sentry.tagstore.snuba.SnubaCompatibilityTagStorage"
         settings.SENTRY_TSDB = "sentry.tsdb.redissnuba.RedisSnubaTSDB"
         settings.SENTRY_EVENTSTREAM = "sentry.eventstream.snuba.SnubaEventStream"
 

tests/sentry/api/endpoints/test_group_details.py

@@ -7,7 +7,6 @@ from base64 import b64encode
 from datetime import timedelta
 from django.utils import timezone
 
-from sentry import tagstore
 from sentry.models import (
     Activity,
     ApiKey,
@@ -67,18 +66,9 @@ class GroupDetailsTest(APITestCase):
     def test_with_first_release(self):
         self.login_as(user=self.user)
 
-        group = self.create_group()
-        release = Release.objects.create(
-            organization_id=group.project.organization_id, version="1.0"
-        )
-        release.add_project(group.project)
-        tagstore.create_group_tag_value(
-            group_id=group.id,
-            project_id=group.project_id,
-            environment_id=self.environment.id,
-            key="sentry:release",
-            value=release.version,
-        )
+        event = self.store_event(data={"release": "1.0"}, project_id=self.project.id)
+
+        group = event.group
 
         url = u"/api/0/issues/{}/".format(group.id)
 
@@ -86,7 +76,7 @@ class GroupDetailsTest(APITestCase):
 
         assert response.status_code == 200, response.content
         assert response.data["id"] == six.text_type(group.id)
-        assert response.data["firstRelease"]["version"] == release.version
+        assert response.data["firstRelease"]["version"] == "1.0"
 
     def test_pending_delete_pending_merge_excluded(self):
         group1 = self.create_group(status=GroupStatus.PENDING_DELETION)

tests/sentry/api/endpoints/test_group_tagkey_details.py

@@ -2,43 +2,29 @@ from __future__ import absolute_import
 
 import six
 
-from sentry import tagstore
-from sentry.testutils import APITestCase
+from sentry.models import Group
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class GroupTagDetailsTest(APITestCase):
+class GroupTagDetailsTest(APITestCase, SnubaTestCase):
     def test_simple(self):
-        group = self.create_group()
-        group.data["tags"] = (["foo", "bar"],)
-        group.save()
+        for i in xrange(3):
+            self.store_event(
+                data={
+                    "tags": {"foo": "bar"},
+                    "fingerprint": ["group1"],
+                    "timestamp": iso_format(before_now(seconds=1)),
+                },
+                project_id=self.project.id,
+            )
 
-        key, value = group.data["tags"][0]
-        tagkey = tagstore.create_tag_key(
-            project_id=group.project_id, environment_id=None, key=key, values_seen=2
-        )
-        tagstore.create_tag_value(
-            project_id=group.project_id, environment_id=None, key=key, value=value, times_seen=4
-        )
-        tagstore.create_group_tag_key(
-            project_id=group.project_id,
-            group_id=group.id,
-            environment_id=None,
-            key=key,
-            values_seen=1,
-        )
-        tagstore.create_group_tag_value(
-            project_id=group.project_id,
-            group_id=group.id,
-            environment_id=None,
-            key=key,
-            value=value,
-            times_seen=3,
-        )
+        group = Group.objects.first()
 
         self.login_as(user=self.user)
 
-        url = u"/api/0/issues/{}/tags/{}/".format(group.id, tagkey.key)
+        url = u"/api/0/issues/{}/tags/{}/".format(group.id, "foo")
         response = self.client.get(url, format="json")
         assert response.status_code == 200, response.content
-        assert response.data["key"] == six.text_type(tagkey.key)
+        assert response.data["key"] == six.text_type("foo")
         assert response.data["totalValues"] == 3

tests/sentry/api/endpoints/test_group_tagkey_values.py

@@ -1,21 +1,20 @@
 from __future__ import absolute_import
 
-from sentry import tagstore
-from sentry.models import EventUser
-from sentry.testutils import APITestCase
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class GroupTagKeyValuesTest(APITestCase):
+class GroupTagKeyValuesTest(APITestCase, SnubaTestCase):
     def test_simple(self):
         key, value = "foo", "bar"
 
         project = self.create_project()
-        group = self.create_group(project=project)
-        tagstore.create_tag_key(project_id=project.id, environment_id=None, key=key)
-        tagstore.create_tag_value(project_id=project.id, environment_id=None, key=key, value=value)
-        tagstore.create_group_tag_value(
-            project_id=project.id, group_id=group.id, environment_id=None, key=key, value=value
+
+        event = self.store_event(
+            data={"tags": {key: value}, "timestamp": iso_format(before_now(seconds=1))},
+            project_id=project.id,
         )
+        group = event.group
 
         self.login_as(user=self.user)
 
@@ -30,25 +29,19 @@ class GroupTagKeyValuesTest(APITestCase):
 
     def test_user_tag(self):
         project = self.create_project()
-        group = self.create_group(project=project)
-        euser = EventUser.objects.create(
-            project_id=project.id,
-            ident="1",
-            email="foo@example.com",
-            username="foo",
-            ip_address="127.0.0.1",
-        )
-        tagstore.create_tag_key(project_id=project.id, environment_id=None, key="sentry:user")
-        tagstore.create_tag_value(
-            project_id=project.id, environment_id=None, key="sentry:user", value=euser.tag_value
-        )
-        tagstore.create_group_tag_value(
+        event = self.store_event(
+            data={
+                "user": {
+                    "id": 1,
+                    "email": "foo@example.com",
+                    "username": "foo",
+                    "ip_address": "127.0.0.1",
+                },
+                "timestamp": iso_format(before_now(seconds=1)),
+            },
             project_id=project.id,
-            group_id=group.id,
-            environment_id=None,
-            key="sentry:user",
-            value=euser.tag_value,
         )
+        group = event.group
 
         self.login_as(user=self.user)
 
@@ -60,4 +53,4 @@ class GroupTagKeyValuesTest(APITestCase):
         assert len(response.data) == 1
 
         assert response.data[0]["email"] == "foo@example.com"
-        assert response.data[0]["value"] == euser.tag_value
+        assert response.data[0]["value"] == "id:1"

tests/sentry/api/endpoints/test_group_tags.py

@@ -1,59 +1,45 @@
 from __future__ import absolute_import
 
-from sentry import tagstore
-from sentry.testutils import APITestCase
-
-
-class GroupTagsTest(APITestCase):
-    def _create_tags(self, group, environment_id=None):
-        for key, values in group.data["tags"]:
-            tagstore.create_tag_key(
-                project_id=group.project_id, environment_id=environment_id, key=key
-            )
-            tagstore.create_group_tag_key(
-                project_id=group.project_id,
-                group_id=group.id,
-                environment_id=environment_id,
-                key=key,
-            )
-
-            if not isinstance(values, list):
-                values = [values]
-            for value in values:
-                tagstore.create_tag_value(
-                    project_id=group.project_id, environment_id=environment_id, key=key, value=value
-                )
-                tagstore.create_group_tag_value(
-                    project_id=group.project_id,
-                    group_id=group.id,
-                    environment_id=environment_id,
-                    key=key,
-                    value=value,
-                )
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
+
+class GroupTagsTest(APITestCase, SnubaTestCase):
     def test_simple(self):
-        this_group = self.create_group()
-        this_group.data["tags"] = (
-            ["foo", ["bar", "quux"]],
-            ["biz", "baz"],
-            ["sentry:release", "releaseme"],
+        event1 = self.store_event(
+            data={
+                "fingerprint": ["group-1"],
+                "tags": {"foo": "bar", "biz": "baz"},
+                "release": "releaseme",
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
+            project_id=self.project.id,
+        )
+        self.store_event(
+            data={
+                "fingerprint": ["group-1"],
+                "tags": {"foo": "quux"},
+                "release": "releaseme",
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
+            project_id=self.project.id,
         )
 
-        this_group.save()
-
-        other_group = self.create_group()
-        other_group.data["tags"] = (["abc", "xyz"],)
-        other_group.save()
-
-        for group in (this_group, other_group):
-            self._create_tags(group)
+        self.store_event(
+            data={
+                "fingerprint": ["group-2"],
+                "tags": {"abc": "xyz"},
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
+            project_id=self.project.id,
+        )
 
         self.login_as(user=self.user)
 
-        url = u"/api/0/issues/{}/tags/".format(this_group.id)
+        url = u"/api/0/issues/{}/tags/".format(event1.group.id)
         response = self.client.get(url, format="json")
         assert response.status_code == 200, response.content
-        assert len(response.data) == 3
+        assert len(response.data) == 4
 
         data = sorted(response.data, key=lambda r: r["key"])
         assert data[0]["key"] == "biz"
@@ -62,11 +48,14 @@ class GroupTagsTest(APITestCase):
         assert data[1]["key"] == "foo"
         assert len(data[1]["topValues"]) == 2
 
-        assert data[2]["key"] == "release"  # Formatted from sentry:release
+        assert data[2]["key"] == "level"
         assert len(data[2]["topValues"]) == 1
 
+        assert data[3]["key"] == "release"  # Formatted from sentry:release
+        assert len(data[3]["topValues"]) == 1
+
         # Use the key= queryparam to grab results for specific tags
-        url = u"/api/0/issues/{}/tags/?key=foo&key=sentry:release".format(this_group.id)
+        url = u"/api/0/issues/{}/tags/?key=foo&key=sentry:release".format(event1.group.id)
         response = self.client.get(url, format="json")
         assert response.status_code == 200, response.content
         assert len(response.data) == 2
@@ -88,15 +77,52 @@ class GroupTagsTest(APITestCase):
         assert response.status_code == 404
 
     def test_valid_env(self):
-        group = self.create_group()
-        group.data["tags"] = (["foo", "bar"], ["biz", "baz"])
-        group.save()
-
-        env = self.create_environment(project=group.project)
-        self._create_tags(group, environment_id=env.id)
+        event = self.store_event(
+            data={
+                "tags": {"foo": "bar", "biz": "baz"},
+                "environment": "prod",
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
+            project_id=self.project.id,
+        )
+        group = event.group
 
         self.login_as(user=self.user)
         url = u"/api/0/issues/{}/tags/".format(group.id)
-        response = self.client.get(url, {"environment": env.name}, format="json")
+        response = self.client.get(url, {"environment": "prod"}, format="json")
         assert response.status_code == 200
-        assert len(response.data) == 2
+        assert len(response.data) == 4
+        assert set([tag["key"] for tag in response.data]) == set(
+            ["foo", "biz", "environment", "level"]
+        )
+
+    def test_multi_env(self):
+        min_ago = before_now(minutes=1)
+        env = self.create_environment(project=self.project, name="prod")
+        env2 = self.create_environment(project=self.project, name="staging")
+        self.store_event(
+            data={
+                "fingerprint": ["put-me-in-group1"],
+                "timestamp": iso_format(min_ago),
+                "environment": env.name,
+                "tags": {"foo": "bar"},
+            },
+            project_id=self.project.id,
+        )
+        event2 = self.store_event(
+            data={
+                "fingerprint": ["put-me-in-group1"],
+                "timestamp": iso_format(min_ago),
+                "environment": env2.name,
+                "tags": {"biz": "baz"},
+            },
+            project_id=self.project.id,
+        )
+
+        self.login_as(user=self.user)
+        url = u"/api/0/issues/{}/tags/?enable_snuba=1".format(event2.group.id)
+        response = self.client.get(
+            "%s&environment=%s&environment=%s" % (url, env.name, env2.name), format="json"
+        )
+        assert response.status_code == 200
+        assert set([tag["key"] for tag in response.data]) >= set(["biz", "environment", "foo"])

tests/sentry/api/endpoints/test_organization_user_issues.py

@@ -2,16 +2,14 @@ from __future__ import absolute_import
 
 import six
 
-from datetime import timedelta
 from django.core.urlresolvers import reverse
-from django.utils import timezone
 
-from sentry import tagstore
 from sentry.models import EventUser, OrganizationMemberTeam
-from sentry.testutils import APITestCase
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class OrganizationUserIssuesTest(APITestCase):
+class OrganizationUserIssuesTest(APITestCase, SnubaTestCase):
     def setUp(self):
         super(OrganizationUserIssuesTest, self).setUp()
         self.org = self.create_organization()
@@ -21,36 +19,42 @@ class OrganizationUserIssuesTest(APITestCase):
         self.team2 = self.create_team(organization=self.org)
         self.project1 = self.create_project(teams=[self.team1])
         self.project2 = self.create_project(teams=[self.team2])
-        self.group1 = self.create_group(
-            project=self.project1, last_seen=timezone.now() - timedelta(minutes=1)
-        )
-        self.group2 = self.create_group(project=self.project2)
-
-        self.euser1 = EventUser.objects.create(email="foo@example.com", project_id=self.project1.id)
-        self.euser2 = EventUser.objects.create(email="bar@example.com", project_id=self.project1.id)
-        self.euser3 = EventUser.objects.create(email="foo@example.com", project_id=self.project2.id)
 
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value=self.euser1.tag_value,
-            group_id=self.group1.id,
+        event1 = self.store_event(
+            data={
+                "fingerprint": ["group1"],
+                "timestamp": iso_format(before_now(seconds=3)),
+                "user": {"email": "foo@example.com"},
+            },
             project_id=self.project1.id,
-            environment_id=None,
         )
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value=self.euser2.tag_value,
-            group_id=self.group1.id,
+
+        event2 = self.store_event(
+            data={
+                "fingerprint": ["group2"],
+                "timestamp": iso_format(before_now(seconds=2)),
+                "user": {"email": "bar@example.com"},
+            },
             project_id=self.project1.id,
-            environment_id=None,
         )
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value=self.euser3.tag_value,
-            group_id=self.group2.id,
+
+        event3 = self.store_event(
+            data={
+                "fingerprint": ["group3"],
+                "timestamp": iso_format(before_now(seconds=1)),
+                "user": {"email": "foo@example.com"},
+            },
             project_id=self.project2.id,
-            environment_id=None,
         )
+
+        self.group1 = event1.group
+        self.group2 = event2.group
+        self.group3 = event3.group
+
+        self.euser1 = EventUser.objects.get(email="foo@example.com", project_id=self.project1.id)
+        self.euser2 = EventUser.objects.get(email="bar@example.com", project_id=self.project1.id)
+        self.euser3 = EventUser.objects.get(email="foo@example.com", project_id=self.project2.id)
+
         self.path = reverse(
             "sentry-api-0-organization-user-issues", args=[self.org.slug, self.euser1.id]
         )
@@ -86,5 +90,5 @@ class OrganizationUserIssuesTest(APITestCase):
         # now result should include results from team2/project2
         assert response.status_code == 200
         assert len(response.data) == 2
-        assert response.data[0]["id"] == six.text_type(self.group2.id)
+        assert response.data[0]["id"] == six.text_type(self.group3.id)
         assert response.data[1]["id"] == six.text_type(self.group1.id)

tests/sentry/api/endpoints/test_organization_user_issues_search.py

@@ -2,53 +2,48 @@ from __future__ import absolute_import
 
 from six.moves.urllib.parse import urlencode
 
-from datetime import timedelta
 from django.core.urlresolvers import reverse
-from django.utils import timezone
 
-from sentry import tagstore
-from sentry.models import EventUser, OrganizationMemberTeam
-from sentry.testutils import APITestCase
+from sentry.models import OrganizationMemberTeam
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class OrganizationUserIssuesSearchTest(APITestCase):
+class OrganizationUserIssuesSearchTest(APITestCase, SnubaTestCase):
     def setUp(self):
         super(OrganizationUserIssuesSearchTest, self).setUp()
-        self.org = self.create_organization()
+        self.org = self.create_organization(owner=None)
         self.org.flags.allow_joinleave = False
         self.org.save()
         self.team1 = self.create_team(organization=self.org)
         self.team2 = self.create_team(organization=self.org)
         self.project1 = self.create_project(teams=[self.team1])
         self.project2 = self.create_project(teams=[self.team2])
-        group1 = self.create_group(
-            project=self.project1, last_seen=timezone.now() - timedelta(minutes=1)
-        )
-        group2 = self.create_group(project=self.project2)
-
-        EventUser.objects.create(email="foo@example.com", project_id=self.project1.id)
-        EventUser.objects.create(email="bar@example.com", project_id=self.project1.id)
-        EventUser.objects.create(email="foo@example.com", project_id=self.project2.id)
 
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value="email:foo@example.com",
-            group_id=group1.id,
-            environment_id=None,
+        self.store_event(
+            data={
+                "user": {"email": "foo@example.com"},
+                "fingerprint": ["group1"],
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
             project_id=self.project1.id,
         )
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value="email:bar@example.com",
-            group_id=group1.id,
-            environment_id=None,
+
+        self.store_event(
+            data={
+                "user": {"email": "bar@example.com"},
+                "fingerprint": ["group1"],
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
             project_id=self.project1.id,
         )
-        tagstore.create_group_tag_value(
-            key="sentry:user",
-            value="email:foo@example.com",
-            group_id=group2.id,
-            environment_id=None,
+
+        self.store_event(
+            data={
+                "user": {"email": "foo@example.com"},
+                "fingerprint": ["group2"],
+                "timestamp": iso_format(before_now(minutes=1)),
+            },
             project_id=self.project2.id,
         )
 
@@ -77,7 +72,6 @@ class OrganizationUserIssuesSearchTest(APITestCase):
 
         url = "%s?%s" % (self.get_url(), urlencode({"email": "foo@example.com"}))
         response = self.client.get(url, format="json")
-
         # result shouldn't include results from team2/project2 or bar@example.com
         assert response.status_code == 200
         assert len(response.data) == 1
@@ -92,5 +86,6 @@ class OrganizationUserIssuesSearchTest(APITestCase):
         # now result should include results from team2/project2
         assert response.status_code == 200
         assert len(response.data) == 2
-        assert response.data[0]["project"]["slug"] == self.project2.slug
-        assert response.data[1]["project"]["slug"] == self.project1.slug
+        assert set([r["project"]["slug"] for r in response.data]) == set(
+            [self.project1.slug, self.project2.slug]
+        )

tests/sentry/api/endpoints/test_project_tagkey_details.py

@@ -6,15 +6,25 @@ from django.core.urlresolvers import reverse
 
 from sentry import tagstore
 from sentry.tagstore import TagKeyStatus
-from sentry.testutils import APITestCase
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class ProjectTagKeyDetailsTest(APITestCase):
+class ProjectTagKeyDetailsTest(APITestCase, SnubaTestCase):
     def test_simple(self):
         project = self.create_project()
-        tagkey = tagstore.create_tag_key(
-            project_id=project.id, environment_id=None, key="foo", values_seen=16
-        )
+
+        def make_event(i):
+            self.store_event(
+                data={
+                    "tags": {"foo": "val{}".format(i)},
+                    "timestamp": iso_format(before_now(seconds=1)),
+                },
+                project_id=project.id,
+            )
+
+        for i in xrange(0, 16):
+            make_event(i)
 
         self.login_as(user=self.user)
 
@@ -23,22 +33,27 @@ class ProjectTagKeyDetailsTest(APITestCase):
             kwargs={
                 "organization_slug": project.organization.slug,
                 "project_slug": project.slug,
-                "key": tagkey.key,
+                "key": "foo",
             },
         )
 
         response = self.client.get(url)
 
         assert response.status_code == 200
-        assert response.data["uniqueValues"] == tagkey.values_seen
+        assert response.data["uniqueValues"] == 16
 
 
 class ProjectTagKeyDeleteTest(APITestCase):
     @mock.patch("sentry.eventstream")
-    @mock.patch("sentry.tagstore.tasks.delete_tag_key")
-    def test_simple(self, mock_delete_tag_key, mock_eventstream):
+    def test_simple(self, mock_eventstream):
+        key = "foo"
+        val = "bar"
+
         project = self.create_project()
-        tagkey = tagstore.create_tag_key(project_id=project.id, environment_id=None, key="foo")
+        self.store_event(
+            data={"tags": {key: val}, "timestamp": iso_format(before_now(seconds=1))},
+            project_id=project.id,
+        )
 
         self.login_as(user=self.user)
 
@@ -50,7 +65,7 @@ class ProjectTagKeyDeleteTest(APITestCase):
             kwargs={
                 "organization_slug": project.organization.slug,
                 "project_slug": project.slug,
-                "key": tagkey.key,
+                "key": key,
             },
         )
 
@@ -58,25 +73,15 @@ class ProjectTagKeyDeleteTest(APITestCase):
 
         assert response.status_code == 204
 
-        from sentry.tagstore.models import TagKey
-
-        mock_delete_tag_key.delay.assert_called_once_with(object_id=tagkey.id, model=TagKey)
-
-        assert (
-            tagstore.get_tag_key(
-                project.id, None, tagkey.key, status=TagKeyStatus.PENDING_DELETION  # environment_id
-            ).status
-            == TagKeyStatus.PENDING_DELETION
-        )
-
         mock_eventstream.start_delete_tag.assert_called_once_with(project.id, "foo")
         mock_eventstream.end_delete_tag.assert_called_once_with(eventstream_state)
 
     @mock.patch("sentry.tagstore.tasks.delete_tag_key")
     def test_protected(self, mock_delete_tag_key):
         project = self.create_project()
-        tagkey = tagstore.create_tag_key(
-            project_id=project.id, environment_id=None, key="environment"
+        self.store_event(
+            data={"environment": "prod", "timestamp": iso_format(before_now(seconds=1))},
+            project_id=project.id,
         )
 
         self.login_as(user=self.user)
@@ -86,7 +91,7 @@ class ProjectTagKeyDeleteTest(APITestCase):
             kwargs={
                 "organization_slug": project.organization.slug,
                 "project_slug": project.slug,
-                "key": tagkey.key,
+                "key": "environment",
             },
         )
 
@@ -97,7 +102,7 @@ class ProjectTagKeyDeleteTest(APITestCase):
 
         assert (
             tagstore.get_tag_key(
-                project.id, None, tagkey.key, status=TagKeyStatus.VISIBLE  # environment_id
+                project.id, None, "environment", status=TagKeyStatus.VISIBLE  # environment_id
             ).status
             == TagKeyStatus.VISIBLE
         )

tests/sentry/api/endpoints/test_project_tagkey_values.py

@@ -2,16 +2,16 @@ from __future__ import absolute_import
 
 from django.core.urlresolvers import reverse
 
-from sentry import tagstore
-from sentry.testutils import APITestCase
+from sentry.testutils import APITestCase, SnubaTestCase
+from sentry.testutils.helpers.datetime import iso_format, before_now
 
 
-class ProjectTagKeyValuesTest(APITestCase):
+class ProjectTagKeyValuesTest(APITestCase, SnubaTestCase):
     def test_simple(self):
         project = self.create_project()
-        tagkey = tagstore.create_tag_key(project_id=project.id, environment_id=None, key="foo")
-        tagstore.create_tag_value(
-            project_id=project.id, environment_id=None, key="foo", value="bar"
+        self.store_event(
+            data={"tags": {"foo": "bar"}, "timestamp": iso_format(before_now(seconds=1))},
+            project_id=project.id,
         )
 
         self.login_as(user=self.user)
@@ -21,7 +21,7 @@ class ProjectTagKeyValuesTest(APITestCase):
             kwargs={
                 "organization_slug": project.organization.slug,
                 "project_slug": project.slug,
-                "key": tagkey.key,
+                "key": "foo",
             },
         )
 
@@ -34,9 +34,9 @@ class ProjectTagKeyValuesTest(APITestCase):
 
     def test_query(self):
         project = self.create_project()
-        tagkey = tagstore.create_tag_key(project_id=project.id, environment_id=None, key="foo")
-        tagstore.create_tag_value(
-            project_id=project.id, environment_id=None, key="foo", value="bar"
+        self.store_event(
+            data={"tags": {"foo": "bar"}, "timestamp": iso_format(before_now(seconds=1))},
+            project_id=project.id,
         )
 
         self.login_as(user=self.user)
@@ -46,7 +46,7 @@ class ProjectTagKeyValuesTest(APITestCase):
             kwargs={
                 "organization_slug": project.organization.slug,
                 "project_slug": project.slug,
-                "key": tagkey.key,
+                "key": "foo",
             },
         )
         response = self.client.get(url + "?query=bar")