ref(tests): Refactor obsolete Sentry store tests (#17756)

 remove/refactor tests that use Sentry Store.

conftest.py

@@ -30,6 +30,7 @@ def pytest_configure(config):
     config.addinivalue_line(
         "markers", "relay_store_integration: mark test as using the relay store endpoint"
     )
+    config.addinivalue_line("markers", "obsolete: mark test as obsolete and soon to be removed")
 
 
 def install_sentry_plugins():

src/sentry/testutils/relay.py

@@ -112,6 +112,12 @@ class RelayStoreHelper(object):
         assert event is not None
         return event
 
+    def post_and_try_retrieve_event(self, data):
+        try:
+            return self.post_and_retrieve_event(data)
+        except AssertionError:
+            return None
+
     def setUp(self):  # NOQA
         self.auth_header = get_auth_header(
             "TEST_USER_AGENT/0.0.0", self.projectkey.public_key, self.projectkey.secret_key, "7"

tests/integration/test_message_filters.py

@@ -1,5 +1,7 @@
 from __future__ import absolute_import
 
+import pytest
+
 from sentry.models.projectoption import ProjectOption
 from sentry.testutils import TestCase
 from sentry.utils.safe import set_path
@@ -11,6 +13,9 @@ from sentry.message_filters import (
 )
 
 
+@pytest.mark.obsolete(
+    "Unit tests in Relay, in the filters implementation files.", "relay-filter/..."
+)
 class FilterTests(TestCase):
     def _get_message(self):
         return {}

tests/integration/tests.py

@@ -9,6 +9,7 @@ import logging
 import six
 from time import sleep
 import zlib
+import pytest
 
 from sentry.utils.compat import mock
 from sentry import eventstore, tagstore
@@ -86,6 +87,7 @@ def load_fixture(name):
         return fp.read()
 
 
+@pytest.mark.obsolete("Remove, behaviour changed, new behaviour tested in Relay")
 class RavenIntegrationTest(TransactionTestCase):
     """
     This mocks the test server and specifically tests behavior that would
@@ -179,18 +181,16 @@ class SentryRemoteTest(TestCase):
         return instance
 
     def test_minimal(self):
-        kwargs = {
+        event_data = {
             "message": "hello",
             "tags": {"foo": "bar"},
             "timestamp": iso_format(before_now(seconds=1)),
         }
 
-        resp = self._postWithHeader(kwargs)
+        event = self.store_event(event_data, self.project.id)
 
-        assert resp.status_code == 200, resp.content
-
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
+        assert event is not None
+        instance = self.get_event(event.event_id)
 
         assert instance.message == "hello"
         assert instance.data["logentry"] == {"formatted": "hello"}
@@ -208,7 +208,7 @@ class SentryRemoteTest(TestCase):
         )
 
     def test_exception(self):
-        kwargs = {
+        event_data = {
             "exception": {
                 "type": "ZeroDivisionError",
                 "value": "cannot divide by zero",
@@ -233,12 +233,10 @@ class SentryRemoteTest(TestCase):
             "timestamp": iso_format(before_now(seconds=1)),
         }
 
-        resp = self._postWithHeader(kwargs)
-
-        assert resp.status_code == 200, resp.content
+        event = self.store_event(event_data, self.project.id)
 
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
+        assert event is not None
+        instance = self.get_event(event.event_id)
 
         assert len(instance.data["exception"]) == 1
         assert (
@@ -261,40 +259,20 @@ class SentryRemoteTest(TestCase):
         timestamp = timezone.now().replace(microsecond=0, tzinfo=timezone.utc) - datetime.timedelta(
             hours=1
         )
-        kwargs = {u"message": "hello", "timestamp": float(timestamp.strftime("%s.%f"))}
-        resp = self._postWithSignature(kwargs)
-        assert resp.status_code == 200, resp.content
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
-        assert instance.message == "hello"
-        assert instance.datetime == timestamp
-        group = instance.group
-        assert group.first_seen == timestamp
-        assert group.last_seen == timestamp
+        event_data = {u"message": "hello", "timestamp": float(timestamp.strftime("%s.%f"))}
+
+        event = self.store_event(event_data, self.project.id)
+
+        assert event is not None
+        instance = self.get_event(event.event_id)
 
-    def test_timestamp_as_iso(self):
-        timestamp = timezone.now().replace(microsecond=0, tzinfo=timezone.utc) - datetime.timedelta(
-            hours=1
-        )
-        kwargs = {u"message": "hello", "timestamp": timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")}
-        resp = self._postWithSignature(kwargs)
-        assert resp.status_code == 200, resp.content
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
         assert instance.message == "hello"
         assert instance.datetime == timestamp
         group = instance.group
         assert group.first_seen == timestamp
         assert group.last_seen == timestamp
 
-    def test_ungzipped_data(self):
-        kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
-        resp = self._postWithSignature(kwargs)
-        assert resp.status_code == 200
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
-        assert instance.message == "hello"
-
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="sentry.io")
     def test_correct_data_with_get(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
@@ -304,6 +282,7 @@ class SentryRemoteTest(TestCase):
         instance = self.get_event(event_id)
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="*")
     def test_get_without_referer_allowed(self):
         self.project.update_option("sentry:origins", "")
@@ -311,6 +290,7 @@ class SentryRemoteTest(TestCase):
         resp = self._getWithReferer(kwargs, referer=None, protocol="4")
         assert resp.status_code == 200, resp.content
 
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="sentry.io")
     def test_correct_data_with_post_referer(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
@@ -320,6 +300,7 @@ class SentryRemoteTest(TestCase):
         instance = self.get_event(event_id)
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="sentry.io")
     def test_post_without_referer(self):
         self.project.update_option("sentry:origins", "")
@@ -327,6 +308,7 @@ class SentryRemoteTest(TestCase):
         resp = self._postWithReferer(kwargs, referer=None, protocol="4")
         assert resp.status_code == 200, resp.content
 
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="*")
     def test_post_without_referer_allowed(self):
         self.project.update_option("sentry:origins", "")
@@ -334,6 +316,7 @@ class SentryRemoteTest(TestCase):
         resp = self._postWithReferer(kwargs, referer=None, protocol="4")
         assert resp.status_code == 200, resp.content
 
+    @pytest.mark.obsolete("Test in relay")
     @override_settings(SENTRY_ALLOW_ORIGIN="google.com")
     def test_post_with_invalid_origin(self):
         self.project.update_option("sentry:origins", "sentry.io")
@@ -341,17 +324,7 @@ class SentryRemoteTest(TestCase):
         resp = self._postWithReferer(kwargs, referer="https://getsentry.net", protocol="4")
         assert resp.status_code == 403, resp.content
 
-    def test_signature(self):
-        kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
-        resp = self._postWithSignature(kwargs)
-
-        assert resp.status_code == 200, resp.content
-
-        event_id = json.loads(resp.content)["id"]
-        instance = self.get_event(event_id)
-
-        assert instance.message == "hello"
-
+    @pytest.mark.obsolete("Test in relay")
     def test_content_encoding_deflate(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
         message = zlib.compress(json.dumps(kwargs))
@@ -375,6 +348,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_content_encoding_gzip(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -407,6 +381,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_protocol_v2_0_without_secret_key(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -419,6 +394,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_protocol_v3(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -436,6 +412,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_protocol_v4(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -453,6 +430,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_protocol_v5(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -470,6 +448,7 @@ class SentryRemoteTest(TestCase):
 
         assert instance.message == "hello"
 
+    @pytest.mark.obsolete("Test in relay")
     def test_protocol_v6(self):
         kwargs = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
 
@@ -488,6 +467,7 @@ class SentryRemoteTest(TestCase):
         assert instance.message == "hello"
 
 
+@pytest.mark.obsolete("Functionality not relevant in Relay store")
 class SentryWsgiRemoteTest(TransactionTestCase):
     @override_settings(ALLOWED_HOSTS=["localhost"])
     def test_traceparent_header_wsgi(self):

tests/relay_integration/lang/javascript/test_example.py

@@ -2,7 +2,7 @@ from __future__ import absolute_import
 
 import pytest
 
-from ....sentry.lang.javascript.test_example import ExampleTestCase
+from tests.sentry.lang.javascript.test_example import ExampleTestCase
 from sentry.testutils import RelayStoreHelper, TransactionTestCase
 
 

tests/relay_integration/lang/javascript/test_plugin.py

@@ -1,7 +1,7 @@
 from __future__ import absolute_import
 import pytest
 
-from ....sentry.lang.javascript.test_plugin import JavascriptIntegrationTest
+from tests.sentry.lang.javascript.test_plugin import JavascriptIntegrationTest
 from sentry.testutils import RelayStoreHelper, TransactionTestCase
 from sentry.testutils.helpers.datetime import iso_format, before_now
 

tests/relay_integration/test_message_filters.py

@@ -0,0 +1,121 @@
+from __future__ import absolute_import, print_function
+
+from django.test import override_settings
+
+from sentry.testutils import TransactionTestCase, RelayStoreHelper
+from sentry.models.projectoption import ProjectOption
+from sentry.utils.safe import set_path
+from sentry.message_filters import (
+    _localhost_filter,
+    _browser_extensions_filter,
+    _web_crawlers_filter,
+    _legacy_browsers_filter,
+)
+
+
+@override_settings(ALLOWED_HOSTS=["localhost", "testserver", "host.docker.internal"])
+class FilterTests(RelayStoreHelper, TransactionTestCase):
+    def setUp(self):  # NOQA
+        RelayStoreHelper.setUp(self)
+
+    def _get_message(self):
+        return {}
+
+    def _set_filter_state(self, flt, state):
+        ProjectOption.objects.set_value(
+            project=self.project, key=u"filters:{}".format(flt.spec.id), value=state
+        )
+
+    def test_should_not_filter_simple_messages(self):
+        # baseline test (so we know everything works as expected)
+        message = self._get_message()
+        self.post_and_retrieve_event(message)
+
+    def _get_message_with_bad_ip(self):
+        message = self._get_message()
+        set_path(message, "user", "ip_address", value="127.0.0.1")
+        return message
+
+    def test_should_filter_local_ip_addresses_when_enabled(self):
+        self._set_filter_state(_localhost_filter, "1")
+        message = self._get_message_with_bad_ip()
+        event = self.post_and_try_retrieve_event(message)
+        assert event is None
+
+    def test_should_not_filter_bad_ip_addresses_when_disabled(self):
+        self._set_filter_state(_localhost_filter, "0")
+        message = self._get_message_with_bad_ip()
+        self.post_and_retrieve_event(message)
+
+    def _get_message_with_bad_extension(self):
+        message = self._get_message()
+        set_path(message, "platform", value="javascript")
+        set_path(
+            message,
+            "exception",
+            value={"values": [{"type": "Error", "value": "http://loading.retry.widdit.com/"}]},
+        )
+        return message
+
+    def test_should_filter_browser_extensions_when_enabled(self):
+        self._set_filter_state(_browser_extensions_filter, "1")
+        message = self._get_message_with_bad_extension()
+        event = self.post_and_try_retrieve_event(message)
+        assert event is None
+
+    def test_should_not_filter_browser_extensions_when_disabled(self):
+        self._set_filter_state(_browser_extensions_filter, "0")
+        message = self._get_message_with_bad_extension()
+        self.post_and_retrieve_event(message)
+
+    def _get_message_from_webcrawler(self):
+        message = self._get_message()
+        set_path(
+            message,
+            "request",
+            value={
+                "url": "http://example.com",
+                "method": "GET",
+                "headers": [["User-Agent", "Mediapartners-Google"]],
+            },
+        )
+        return message
+
+    def test_should_filter_web_crawlers_when_enabled(self):
+        self._set_filter_state(_web_crawlers_filter, "1")
+        message = self._get_message_from_webcrawler()
+        event = self.post_and_try_retrieve_event(message)
+        assert event is None
+
+    def test_should_not_filter_web_crawlers_when_disabled(self):
+        self._set_filter_state(_web_crawlers_filter, "0")
+        message = self._get_message_from_webcrawler()
+        self.post_and_retrieve_event(message)
+
+    def _get_message_from_legacy_browser(self):
+        ie_5_user_agent = (
+            "Mozilla/4.0 (compatible; MSIE 5.50; Windows NT; SiteKiosk 4.9; SiteCoach 1.0)"
+        )
+        message = self._get_message()
+        set_path(message, "platform", value="javascript")
+        set_path(
+            message,
+            "request",
+            value={
+                "url": "http://example.com",
+                "method": "GET",
+                "headers": [["User-Agent", ie_5_user_agent]],
+            },
+        )
+        return message
+
+    def test_should_filter_legacy_browsers(self):
+        self._set_filter_state(_legacy_browsers_filter, "1")
+        message = self._get_message_from_legacy_browser()
+        event = self.post_and_try_retrieve_event(message)
+        assert event is None
+
+    def test_should_not_filter_legacy_browsers_when_disabled(self):
+        self._set_filter_state(_legacy_browsers_filter, "0")
+        message = self._get_message_from_legacy_browser()
+        self.post_and_retrieve_event(message)

tests/relay_integration/tests.py

@@ -0,0 +1,36 @@
+from __future__ import absolute_import, print_function
+
+import os
+
+from sentry import eventstore
+
+from django.core.urlresolvers import reverse
+from exam import fixture
+from sentry.testutils import TransactionTestCase, RelayStoreHelper
+from sentry.testutils.helpers.datetime import iso_format, before_now
+
+
+def get_fixture_path(name):
+    return os.path.join(os.path.dirname(__file__), "fixtures", name)
+
+
+def load_fixture(name):
+    with open(get_fixture_path(name)) as fp:
+        return fp.read()
+
+
+class SentryRemoteTest(RelayStoreHelper, TransactionTestCase):
+    @fixture
+    def path(self):
+        return reverse("sentry-api-store")
+
+    def get_event(self, event_id):
+        instance = eventstore.get_event_by_id(self.project.id, event_id)
+        return instance
+
+    # used to be test_ungzipped_data
+    def test_simple_data(self):
+        event_data = {"message": "hello", "timestamp": iso_format(before_now(seconds=1))}
+        event = self.post_and_retrieve_event(event_data)
+
+        assert event.message == "hello"

tests/sentry/web/api/tests.py

@@ -2,6 +2,7 @@
 
 from __future__ import absolute_import
 
+import pytest
 from sentry.utils.compat import mock
 
 from django.core.urlresolvers import reverse
@@ -18,20 +19,24 @@ from sentry.utils import json
 from sentry.utils.data_filters import FilterTypes
 
 
+@pytest.mark.obsolete("functionality moved and tested in Relay")
 class SecurityReportCspTest(TestCase):
     @fixture
     def path(self):
         path = reverse("sentry-api-security-report", kwargs={"project_id": self.project.id})
         return path + "?sentry_key=%s" % self.projectkey.public_key
 
+    @pytest.mark.obsolete("can be removed, covered in Relay")
     def test_get_response(self):
         resp = self.client.get(self.path)
         assert resp.status_code == 405, resp.content
 
+    @pytest.mark.obsolete("can be removed, NOT worth porting to Relay")
     def test_invalid_content_type(self):
         resp = self.client.post(self.path, content_type="text/plain")
         assert resp.status_code == 400, resp.content
 
+    @pytest.mark.obsolete("can be removed, NOT worth porting to Relay")
     def test_missing_csp_report(self):
         resp = self.client.post(
             self.path,
@@ -41,13 +46,17 @@ class SecurityReportCspTest(TestCase):
         )
         assert resp.status_code == 400, resp.content
 
+    @pytest.mark.obsolete(
+        "ported to Relay", "tests/integration/test_security_report.py::test_uses_origins"
+    )
     @mock.patch("sentry.utils.http.get_origins")
     def test_bad_origin(self, get_origins):
         get_origins.return_value = ["example.com"]
         resp = self.client.post(
             self.path,
             content_type="application/csp-report",
-            data='{"csp-report":{"document-uri":"http://lolnope.com","effective-directive":"img-src","violated-directive":"img-src","source-file":"test.html"}}',
+            data='{"csp-report":{"document-uri":"http://lolnope.com","effective-directive":"img-src",'
+            '"violated-directive":"img-src","source-file":"test.html"}}',
             HTTP_USER_AGENT="awesome",
         )
         assert resp.status_code == 403, resp.content
@@ -61,6 +70,10 @@ class SecurityReportCspTest(TestCase):
         )
         assert resp.status_code == 400, resp.content
 
+    @pytest.mark.obsolete(
+        "already covered in Relay by multiple integration tests",
+        "tests/integration/test_security_report.py",
+    )
     @mock.patch("sentry.web.api.is_valid_origin", mock.Mock(return_value=True))
     @mock.patch("sentry.web.api.SecurityReportView.process")
     def test_post_success(self, process):
@@ -77,6 +90,7 @@ class SecurityReportCspTest(TestCase):
         assert resp.status_code == 201, resp.content
 
 
+@pytest.mark.obsolete("functionality moved and tested in Relay")
 class SecurityReportHpkpTest(TestCase):
     @fixture
     def path(self):
@@ -111,6 +125,10 @@ class SecurityReportHpkpTest(TestCase):
         assert resp.status_code == 201, resp.content
 
 
+@pytest.mark.obsolete(
+    "functionality moved and tested in Relay",
+    "tests/integration/test_security_report.py::test_security_reports_no_processing",
+)
 class SecurityReportExpectCTTest(TestCase):
     @fixture
     def path(self):
@@ -153,6 +171,10 @@ class SecurityReportExpectCTTest(TestCase):
         assert resp.status_code == 201, resp.content
 
 
+@pytest.mark.obsolete(
+    "functionality moved and tested in Relay",
+    "tests/integration/test_security_report.py::test_security_reports_no_processing",
+)
 class SecurityReportExpectStapleTest(TestCase):
     @fixture
     def path(self):
@@ -189,11 +211,13 @@ class SecurityReportExpectStapleTest(TestCase):
         assert resp.status_code == 201, resp.content
 
 
+@pytest.mark.obsolete("functionality moved in Relay")
 class StoreViewTest(TestCase):
     @fixture
     def path(self):
         return reverse("sentry-api-store", kwargs={"project_id": self.project.id})
 
+    @pytest.mark.obsolete("covered in Relay", "tests/integration/test_store.py")
     @mock.patch("sentry.web.api.StoreView._parse_header")
     def test_options_response(self, parse_header):
         project = self.create_project()
@@ -210,24 +234,36 @@ class StoreViewTest(TestCase):
         assert resp.has_header("Content-Length")
         self.assertEquals(resp["Content-Length"], "0")
 
+    @pytest.mark.obsolete(
+        "Will not be directly tested since implementation is part of axis-web CORS"
+    )
     def test_options_with_no_origin_or_referrer(self):
         resp = self.client.options(self.path)
         assert resp.status_code == 200, (resp.status_code, resp.content)
         assert resp.has_header("Access-Control-Allow-Origin")
         self.assertEquals(resp["Access-Control-Allow-Origin"], "*")
 
+    @pytest.mark.obsolete(
+        "Will not be directly tested since implementation is part of axis-web CORS"
+    )
     def test_options_response_with_valid_origin(self):
         resp = self.client.options(self.path, HTTP_ORIGIN="http://foo.com")
         assert resp.status_code == 200, (resp.status_code, resp.content)
         assert resp.has_header("Access-Control-Allow-Origin")
         self.assertEquals(resp["Access-Control-Allow-Origin"], "http://foo.com")
 
+    @pytest.mark.obsolete(
+        "Will not be directly tested since implementation is part of axis-web CORS"
+    )
     def test_options_response_with_valid_referrer(self):
         resp = self.client.options(self.path, HTTP_REFERER="http://foo.com")
         assert resp.status_code == 200, (resp.status_code, resp.content)
         assert resp.has_header("Access-Control-Allow-Origin")
         self.assertEquals(resp["Access-Control-Allow-Origin"], "http://foo.com")
 
+    @pytest.mark.obsolete(
+        "Will not be directly tested since implementation is part of axis-web CORS"
+    )
     def test_options_response_origin_preferred_over_referrer(self):
         resp = self.client.options(
             self.path, HTTP_REFERER="http://foo.com", HTTP_ORIGIN="http://bar.com"
@@ -236,11 +272,13 @@ class StoreViewTest(TestCase):
         assert resp.has_header("Access-Control-Allow-Origin")
         self.assertEquals(resp["Access-Control-Allow-Origin"], "http://bar.com")
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/client_ips.rs")
     @mock.patch("sentry.event_manager.is_valid_ip", mock.Mock(return_value=False))
     def test_request_with_blacklisted_ip(self):
         resp = self._postWithHeader({})
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/releases.rs")
     @mock.patch("sentry.event_manager.is_valid_release", mock.Mock(return_value=False))
     def test_request_with_filtered_release(self):
         body = {
@@ -256,6 +294,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/error_messages.rs")
     @mock.patch("sentry.event_manager.is_valid_error_message", mock.Mock(return_value=False))
     def test_request_with_filtered_error(self):
         body = {
@@ -271,6 +310,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/client_ips.rs")
     def test_request_with_invalid_ip(self):
         self.project.update_option("sentry:blacklisted_ips", ["127.0.0.1"])
         body = {
@@ -286,6 +326,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/releases.rs")
     def test_request_with_invalid_release(self):
         self.project.update_option(u"sentry:{}".format(FilterTypes.RELEASES), ["1.3.2"])
         body = {
@@ -301,6 +342,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/releases.rs")
     def test_request_with_short_release_globbing(self):
         self.project.update_option(u"sentry:{}".format(FilterTypes.RELEASES), ["1.*"])
         body = {
@@ -316,6 +358,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/releases.rs")
     def test_request_with_longer_release_globbing(self):
         self.project.update_option(u"sentry:{}".format(FilterTypes.RELEASES), ["2.1.*"])
         body = {
@@ -351,6 +394,9 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete(
+        "Moved to Relay", "tests/integration/test_basic.py::test_store_allowed_origins_passes"
+    )
     @mock.patch("sentry.relay.config.get_origins")
     def test_request_with_bad_origin(self, get_origins):
         get_origins.return_value = ["foo.com"]
@@ -361,6 +407,7 @@ class StoreViewTest(TestCase):
         assert resp.status_code == 403, (resp.status_code, resp.content)
         assert b"Invalid origin" in resp.content
 
+    @pytest.mark.obsolete("Unit test in Relay", "relay-filter/error_messages.rs")
     def test_request_with_beginning_glob(self):
         self.project.update_option(
             u"sentry:{}".format(FilterTypes.ERROR_MESSAGES),
@@ -382,6 +429,7 @@ class StoreViewTest(TestCase):
         resp = self._postWithHeader(body)
         assert resp.status_code == 403, (resp.status_code, resp.content)
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrubs_ip_address(self, mock_insert_data_to_database):
         self.project.update_option("sentry:scrub_ip_address", True)
@@ -403,6 +451,7 @@ class StoreViewTest(TestCase):
         assert not call_data["request"]["env"].get("REMOTE_ADDR")
         assert not call_data["sdk"].get("client_ip")
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrubs_org_ip_address_override(self, mock_insert_data_to_database):
         self.organization.update_option("sentry:require_scrub_ip_address", True)
@@ -423,6 +472,7 @@ class StoreViewTest(TestCase):
         assert not call_data["user"].get("ip_address")
         assert not call_data["request"]["env"].get("REMOTE_ADDR")
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_off(self, mock_insert_data_to_database):
         self.project.update_option("sentry:scrub_data", False)
@@ -447,6 +497,7 @@ class StoreViewTest(TestCase):
             "baz": "3",
         }
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_on(self, mock_insert_data_to_database):
         self.project.update_option("sentry:scrub_data", True)
@@ -471,6 +522,7 @@ class StoreViewTest(TestCase):
             "baz": "3",
         }
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_defaults(self, mock_insert_data_to_database):
         self.project.update_option("sentry:scrub_data", True)
@@ -495,6 +547,7 @@ class StoreViewTest(TestCase):
             "baz": "3",
         }
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_sensitive_fields(self, mock_insert_data_to_database):
         self.project.update_option("sentry:scrub_data", True)
@@ -520,6 +573,7 @@ class StoreViewTest(TestCase):
             "baz": "3",
         }
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_org_override(self, mock_insert_data_to_database):
         self.organization.update_option("sentry:require_scrub_data", True)
@@ -546,6 +600,7 @@ class StoreViewTest(TestCase):
             "baz": "3",
         }
 
+    @pytest.mark.obsolete("Unit test in Relay, PII/data scrubbing")
     @mock.patch("sentry.coreapi.ClientApiHelper.insert_data_to_database")
     def test_scrub_data_org_override_sensitive_fields(self, mock_insert_data_to_database):
         self.organization.update_option("sentry:require_scrub_data", True)