ref(tests): Clean up tests with get_valid_response (#24628)

src/sentry/testutils/asserts.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from sentry.models import CommitFileChange
 
 
@@ -29,3 +31,9 @@ def assert_commit_shape(commit):
     for patch in patches:
         assert patch["type"] in commit_file_type_choices
         assert patch["path"]
+
+
+def assert_status_code(response, minimum: int, maximum: Optional[int] = None):
+    # Omit max to assert status_code == minimum.
+    maximum = maximum or minimum + 1
+    assert minimum <= response.status_code < maximum, (response.status_code, response.content)

src/sentry/testutils/cases.py

@@ -80,12 +80,13 @@ from sentry.models import (
 from sentry.plugins.base import plugins
 from sentry.rules import EventState
 from sentry.tagstore.snuba import SnubaTagStorage
+from sentry.testutils.helpers.datetime import iso_format
 from sentry.utils import json
 from sentry.utils.auth import SSO_SESSION_KEY
-from sentry.testutils.helpers.datetime import iso_format
+from sentry.utils.pytest.selenium import Browser
 from sentry.utils.retries import TimedRetryPolicy
 from sentry.utils.snuba import _snuba_pool
-from sentry.utils.pytest.selenium import Browser
+from . import assert_status_code
 from .fixtures import Fixtures
 from .factories import Factories
 from .skips import requires_snuba
@@ -339,10 +340,27 @@ class TransactionTestCase(BaseTestCase, TransactionTestCase):
 
 
 class APITestCase(BaseTestCase, BaseAPITestCase):
+    """
+    Extend APITestCase to inherit access to `client`, an object with methods
+    that simulate API calls to Sentry, and the helper `get_response`, which
+    combines and simplify a lot of tedious parts of making API calls in tests.
+    When creating API tests, use a new class per endpoint-method pair. The class
+    must set the string `endpoint`.
+    """
+
     endpoint = None
     method = "get"
 
     def get_response(self, *args, **params):
+        """
+        Simulate an API call to the test case's URI and method.
+
+        :param params:
+            * qs_params: (Optional) Dict mapping keys to values that will be
+             url-encoded into a API call's query string. Note: The name is
+             intentionally a little funny to prevent name collisions.
+        :returns Response object
+        """
         if self.endpoint is None:
             raise Exception("Implement self.endpoint to use this method.")
 
@@ -358,11 +376,59 @@ class APITestCase(BaseTestCase, BaseAPITestCase):
         return getattr(self.client, method)(url, format="json", data=params)
 
     def get_valid_response(self, *args, **params):
+        """ Deprecated. Calls `get_response` (see above) and asserts a specific status code. """
         status_code = params.pop("status_code", 200)
         resp = self.get_response(*args, **params)
         assert resp.status_code == status_code, (resp.status_code, resp.content)
         return resp
 
+    def get_success_response(self, *args, **params):
+        """
+        Call `get_response` (see above) and assert the response's status code.
+
+        :param params:
+            * status_code: (Optional) Assert that the response's status code is
+            a specific code. Omit to assert any successful status_code.
+        :returns Response object
+        """
+        status_code = params.pop("status_code", None)
+
+        if status_code >= 400:
+            raise Exception("status_code must be < 400")
+
+        response = self.get_response(*args, **params)
+
+        if status_code:
+            assert_status_code(response, status_code)
+        else:
+            assert_status_code(response, 200, 300)
+
+        return response
+
+    def get_error_response(self, *args, **params):
+        """
+        Call `get_response` (see above) and assert that the response's status
+        code is an error code. Basically it's syntactic sugar.
+
+        :param params:
+            * status_code: (Optional) Assert that the response's status code is
+            a specific error code. Omit to assert any error status_code.
+        :returns Response object
+        """
+        status_code = params.pop("status_code", None)
+
+        if status_code < 400:
+            raise Exception("status_code must be >= 400 (an error status code)")
+
+        response = self.get_response(*args, **params)
+
+        if status_code:
+            assert_status_code(response, status_code)
+        else:
+            assert_status_code(response, 400, 600)
+
+        return response
+
 
 class TwoFactorAPITestCase(APITestCase):
     @fixture

tests/sentry/api/endpoints/test_api_authorizations.py

@@ -1,32 +1,36 @@
-from django.core.urlresolvers import reverse
-
 from sentry.models import ApiApplication, ApiAuthorization, ApiToken
 from sentry.testutils import APITestCase
 
 
-class ApiAuthorizationsListTest(APITestCase):
+class ApiAuthorizationsTest(APITestCase):
+    endpoint = "sentry-api-0-api-authorizations"
+
+    def setUp(self):
+        super().setUp()
+        self.login_as(self.user)
+
+
+class ApiAuthorizationsListTest(ApiAuthorizationsTest):
     def test_simple(self):
         app = ApiApplication.objects.create(name="test", owner=self.user)
         auth = ApiAuthorization.objects.create(application=app, user=self.user)
         ApiAuthorization.objects.create(
             application=app, user=self.create_user("example@example.com")
         )
-        self.login_as(self.user)
-        url = reverse("sentry-api-0-api-authorizations")
-        response = self.client.get(url)
-        assert response.status_code == 200, response.content
+
+        response = self.get_valid_response()
         assert len(response.data) == 1
         assert response.data[0]["id"] == str(auth.id)
 
 
-class ApiAuthorizationsDeleteTest(APITestCase):
+class ApiAuthorizationsDeleteTest(ApiAuthorizationsTest):
+    method = "delete"
+
     def test_simple(self):
         app = ApiApplication.objects.create(name="test", owner=self.user)
         auth = ApiAuthorization.objects.create(application=app, user=self.user)
         token = ApiToken.objects.create(application=app, user=self.user)
-        self.login_as(self.user)
-        url = reverse("sentry-api-0-api-authorizations")
-        response = self.client.delete(url, data={"authorization": auth.id})
-        assert response.status_code == 204
+
+        self.get_valid_response(authorization=auth.id, status_code=204)
         assert not ApiAuthorization.objects.filter(id=auth.id).exists()
         assert not ApiToken.objects.filter(id=token.id).exists()

tests/sentry/api/endpoints/test_organization_index.py

@@ -143,6 +143,8 @@ class OrganizationsCreateTest(APITestCase):
 
 
 class OrganizationIndex2faTest(TwoFactorAPITestCase):
+    endpoint = "sentry-organization-home"
+
     def setUp(self):
         self.org_2fa = self.create_organization(owner=self.create_user())
         self.enable_org_2fa(self.org_2fa)
@@ -154,12 +156,10 @@ class OrganizationIndex2faTest(TwoFactorAPITestCase):
         return reverse("sentry-organization-home", kwargs={"organization_slug": self.org_2fa.slug})
 
     def assert_can_access_org_home(self):
-        response = self.client.get(self.path)
-        assert response.status_code == 200
+        self.get_valid_response(self.org_2fa.slug)
 
     def assert_redirected_to_2fa(self):
-        response = self.client.get(self.path)
-        assert response.status_code == 302
+        response = self.get_valid_response(self.org_2fa.slug, status_code=302)
         assert self.path_2fa in response.url
 
     def test_preexisting_members_must_enable_2fa(self):

tests/sentry/api/endpoints/test_organization_projects.py

@@ -1,150 +1,150 @@
 from base64 import b64encode
 
-from exam import fixture
+from django.urls import reverse
 
 from sentry.models import ApiKey
 from sentry.testutils import APITestCase
 
 
-class OrganizationProjectsTest(APITestCase):
-    @fixture
-    def path(self):
-        return f"/api/0/organizations/{self.organization.slug}/projects/"
+class OrganizationProjectsTestBase(APITestCase):
+    endpoint = "sentry-api-0-organization-projects"
 
-    def check_valid_response(self, response, expected_projects):
-        assert response.status_code == 200, response.content
+    @staticmethod
+    def check_valid_response(response, expected_projects):
         assert [project.id for project in expected_projects] == [
             int(project_resp["id"]) for project_resp in response.data
         ]
 
-    def test_simple(self):
+    def test_api_key(self):
+        key = ApiKey.objects.create(organization=self.organization, scope_list=["org:read"])
+
+        project = self.create_project(teams=[self.team])
+
+        path = reverse(self.endpoint, args=[self.organization.slug])
+        response = self.client.get(
+            path,
+            HTTP_AUTHORIZATION=b"Basic " + b64encode(f"{key.key}:".encode("utf-8")),
+        )
+        self.check_valid_response(response, [project])
+
+
+class OrganizationProjectsTest(OrganizationProjectsTestBase):
+    def setUp(self):
+        super().setUp()
         self.login_as(user=self.user)
+
+    def test_simple(self):
         project = self.create_project(teams=[self.team])
 
-        response = self.client.get(self.path)
+        response = self.get_valid_response(self.organization.slug)
         self.check_valid_response(response, [project])
         assert self.client.session["activeorg"] == self.organization.slug
 
     def test_with_stats(self):
-        self.login_as(user=self.user)
-
         projects = [self.create_project(teams=[self.team])]
 
-        response = self.client.get(f"{self.path}?statsPeriod=24h", format="json")
+        response = self.get_valid_response(self.organization.slug, qs_params={"statsPeriod": "24h"})
         self.check_valid_response(response, projects)
         assert "stats" in response.data[0]
 
-        response = self.client.get(f"{self.path}?statsPeriod=14d", format="json")
+        response = self.get_valid_response(self.organization.slug, qs_params={"statsPeriod": "14d"})
         self.check_valid_response(response, projects)
         assert "stats" in response.data[0]
 
-        response = self.client.get(f"{self.path}?statsPeriod=", format="json")
+        response = self.get_valid_response(self.organization.slug, qs_params={"statsPeriod": ""})
         self.check_valid_response(response, projects)
         assert "stats" not in response.data[0]
 
-        response = self.client.get(f"{self.path}?statsPeriod=48h", format="json")
-        assert response.status_code == 400
+        self.get_valid_response(
+            self.organization.slug, qs_params={"statsPeriod": "48h"}, status_code=400
+        )
 
     def test_search(self):
-        self.login_as(user=self.user)
         project = self.create_project(teams=[self.team], name="bar", slug="bar")
 
-        response = self.client.get(f"{self.path}?query=bar")
+        response = self.get_valid_response(self.organization.slug, qs_params={"query": "bar"})
         self.check_valid_response(response, [project])
 
-        response = self.client.get(f"{self.path}?query=baz")
+        response = self.get_valid_response(self.organization.slug, qs_params={"query": "baz"})
         self.check_valid_response(response, [])
 
     def test_search_by_ids(self):
-        self.login_as(user=self.user)
-
         project_bar = self.create_project(teams=[self.team], name="bar", slug="bar")
         project_foo = self.create_project(teams=[self.team], name="foo", slug="foo")
         self.create_project(teams=[self.team], name="baz", slug="baz")
 
-        path = f"{self.path}?query=id:{project_foo.id}"
-        response = self.client.get(path)
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": f"id:{project_foo.id}"}
+        )
         self.check_valid_response(response, [project_foo])
 
-        path = f"{self.path}?query=id:{project_bar.id} id:{project_foo.id}"
-        response = self.client.get(path)
-
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": f"id:{project_bar.id} id:{project_foo.id}"}
+        )
         self.check_valid_response(response, [project_bar, project_foo])
 
     def test_search_by_slugs(self):
-        self.login_as(user=self.user)
-
         project_bar = self.create_project(teams=[self.team], name="bar", slug="bar")
         project_foo = self.create_project(teams=[self.team], name="foo", slug="foo")
         self.create_project(teams=[self.team], name="baz", slug="baz")
 
-        path = f"{self.path}?query=slug:{project_foo.slug}"
-        response = self.client.get(path)
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": f"slug:{project_foo.slug}"}
+        )
         self.check_valid_response(response, [project_foo])
 
-        path = f"{self.path}?query=slug:{project_bar.slug} slug:{project_foo.slug}"
-        response = self.client.get(path)
-
+        response = self.get_valid_response(
+            self.organization.slug,
+            qs_params={"query": f"slug:{project_bar.slug} slug:{project_foo.slug}"},
+        )
         self.check_valid_response(response, [project_bar, project_foo])
 
     def test_bookmarks_appear_first_across_pages(self):
-        self.login_as(user=self.user)
-
         projects = [
             self.create_project(teams=[self.team], name=i, slug=f"project-{i}") for i in range(3)
         ]
         projects.sort(key=lambda project: project.slug)
 
-        response = self.client.get(self.path)
+        response = self.get_valid_response(self.organization.slug)
         self.check_valid_response(response, [project for project in projects])
 
-        response = self.client.get(self.path + "?per_page=2")
+        response = self.get_valid_response(self.organization.slug, qs_params={"per_page": "2"})
         self.check_valid_response(response, [project for project in projects[:2]])
 
         self.create_project_bookmark(projects[-1], user=self.user)
         # Move the bookmarked project to the front
         projects.insert(0, projects.pop())
-        response = self.client.get(self.path)
+        response = self.get_valid_response(self.organization.slug)
         self.check_valid_response(response, [project for project in projects])
 
         # Make sure that it's at the front when on the second page as well
-        response = self.client.get(self.path + "?per_page=2")
+        response = self.get_valid_response(self.organization.slug, qs_params={"per_page": "2"})
         self.check_valid_response(response, [project for project in projects[:2]])
 
         # Make sure that other user's bookmarks don't interfere with this user
         other_user = self.create_user()
         self.create_project_bookmark(projects[1], user=other_user)
-        response = self.client.get(self.path)
+        response = self.get_valid_response(self.organization.slug)
         self.check_valid_response(response, [project for project in projects])
 
     def test_team_filter(self):
-        self.login_as(user=self.user)
         other_team = self.create_team(organization=self.organization)
 
         project_bar = self.create_project(teams=[self.team], name="bar", slug="bar")
         project_foo = self.create_project(teams=[other_team], name="foo", slug="foo")
         project_baz = self.create_project(teams=[other_team], name="baz", slug="baz")
-        path = f"{self.path}?query=team:{self.team.slug}"
-        response = self.client.get(path)
-        self.check_valid_response(response, [project_bar])
 
-        path = f"{self.path}?query=!team:{self.team.slug}"
-        response = self.client.get(path)
-        self.check_valid_response(response, [project_baz, project_foo])
-
-    def test_api_key(self):
-        key = ApiKey.objects.create(organization=self.organization, scope_list=["org:read"])
-
-        project = self.create_project(teams=[self.team])
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": f"team:{self.team.slug}"}
+        )
+        self.check_valid_response(response, [project_bar])
 
-        response = self.client.get(
-            self.path,
-            HTTP_AUTHORIZATION=b"Basic " + b64encode(f"{key.key}:".encode("utf-8")),
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": f"!team:{self.team.slug}"}
         )
-        self.check_valid_response(response, [project])
+        self.check_valid_response(response, [project_baz, project_foo])
 
     def test_all_projects(self):
-        self.login_as(user=self.user)
         other_team = self.create_team(organization=self.organization)
 
         project_bar = self.create_project(teams=[self.team], name="bar", slug="bar")
@@ -152,16 +152,19 @@ class OrganizationProjectsTest(APITestCase):
         project_baz = self.create_project(teams=[other_team], name="baz", slug="baz")
         sorted_projects = [project_bar, project_baz, project_foo]
 
-        response = self.client.get(self.path + "?all_projects=1&per_page=1")
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"all_projects": "1", "per_page": "1"}
+        )
         # Verify all projects in the org are returned in sorted order
         self.check_valid_response(response, sorted_projects)
 
     def test_all_projects_collapse(self):
-        self.login_as(user=self.user)
         project_bar = self.create_project(teams=[self.team], name="bar", slug="bar")
         sorted_projects = [project_bar]
 
-        response = self.client.get(self.path + "?all_projects=1&collapse=latestDeploy")
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"all_projects": "1", "collapse": "latestDeploy"}
+        )
         # Verify all projects in the org are returned in sorted order
         self.check_valid_response(response, sorted_projects)
         assert "latestDeploy" not in response.data[0]
@@ -181,20 +184,22 @@ class OrganizationProjectsTest(APITestCase):
 
         foo_user_projects = [project_bar]
 
-        response = self.client.get(self.path + "?query=is_member:1")
+        response = self.get_valid_response(
+            self.organization.slug, qs_params={"query": "is_member:1"}
+        )
         # Verify projects that were returned were foo_users projects
         self.check_valid_response(response, foo_user_projects)
 
 
 class OrganizationProjectsCountTest(APITestCase):
-    @fixture
-    def path(self):
-        return f"/api/0/organizations/{self.organization.slug}/projects-count/"
+    endpoint = "sentry-api-0-organization-projects-count"
 
-    def test_project_count(self):
+    def setUp(self):
+        super().setUp()
         self.foo_user = self.create_user("foo@example.com")
         self.login_as(user=self.foo_user)
 
+    def test_project_count(self):
         other_team = self.create_team(organization=self.organization)
 
         self.create_project(teams=[self.team], name="bar", slug="bar")
@@ -207,6 +212,5 @@ class OrganizationProjectsCountTest(APITestCase):
         # Make foo_user a part of the org and self.team
         self.create_member(organization=self.organization, user=self.foo_user, teams=[self.team])
 
-        response = self.client.get(self.path + "?get_counts=1")
-        assert response.status_code == 200, response.content
+        response = self.get_valid_response(self.organization.slug, qs_params={"get_counts": "1"})
         assert response.data == {"allProjects": 6, "myProjects": 4}

tests/sentry/api/endpoints/test_organization_teams.py

@@ -92,6 +92,13 @@ class OrganizationTeamsListTest(APITestCase):
 
 
 class OrganizationTeamsCreateTest(APITestCase):
+    endpoint = "sentry-api-0-organization-teams"
+    method = "post"
+
+    def setUp(self):
+        super().setUp()
+        self.login_as(user=self.user)
+
     @fixture
     def path(self):
         return reverse("sentry-api-0-organization-teams", args=[self.organization.slug])
@@ -99,20 +106,18 @@ class OrganizationTeamsCreateTest(APITestCase):
     def test_missing_permission(self):
         user = self.create_user()
         self.login_as(user=user)
-        resp = self.client.post(self.path)
-        assert resp.status_code == 403
+
+        self.get_valid_response(self.organization.slug, status_code=403)
 
     def test_missing_params(self):
-        self.login_as(user=self.user)
-        resp = self.client.post(self.path)
-        assert resp.status_code == 400
+        resp = self.get_valid_response(self.organization.slug, status_code=400)
         assert b"Name or slug is required" in resp.content
 
     def test_valid_params(self):
-        self.login_as(user=self.user)
+        resp = self.get_valid_response(
+            self.organization.slug, name="hello world", slug="foobar", status_code=201
+        )
 
-        resp = self.client.post(self.path, data={"name": "hello world", "slug": "foobar"})
-        assert resp.status_code == 201, resp.content
         team = Team.objects.get(id=resp.data["id"])
         assert team.name == "hello world"
         assert team.slug == "foobar"
@@ -125,36 +130,27 @@ class OrganizationTeamsCreateTest(APITestCase):
         ).exists()
 
     def test_without_slug(self):
-        self.login_as(user=self.user)
+        resp = self.get_valid_response(self.organization.slug, name="hello world", status_code=201)
 
-        resp = self.client.post(self.path, data={"name": "hello world"})
-        assert resp.status_code == 201, resp.content
         team = Team.objects.get(id=resp.data["id"])
         assert team.slug == "hello-world"
 
     def test_without_name(self):
-        self.login_as(user=self.user)
+        resp = self.get_valid_response(self.organization.slug, slug="example-slug", status_code=201)
 
-        resp = self.client.post(self.path, data={"slug": "example-slug"})
-        assert resp.status_code == 201, resp.content
         team = Team.objects.get(id=resp.data["id"])
         assert team.slug == "example-slug"
         assert team.name == "example-slug"
 
     def test_duplicate(self):
-        self.login_as(user=self.user)
-
-        resp = self.client.post(self.path, data={"name": "hello world", "slug": "foobar"})
-
-        assert resp.status_code == 201, resp.content
-
-        resp = self.client.post(self.path, data={"name": "hello world", "slug": "foobar"})
-
-        assert resp.status_code == 409, resp.content
+        self.get_valid_response(
+            self.organization.slug, name="hello world", slug="foobar", status_code=201
+        )
+        self.get_valid_response(
+            self.organization.slug, name="hello world", slug="foobar", status_code=409
+        )
 
     def test_name_too_long(self):
-        self.login_as(user=self.user)
-
-        resp = self.client.post(self.path, data={"name": "x" * 65, "slug": "xxxxxxx"})
-
-        assert resp.status_code == 400, resp.content
+        self.get_valid_response(
+            self.organization.slug, name="x" * 65, slug="xxxxxxx", status_code=400
+        )

tests/sentry/api/endpoints/test_organization_user_details.py

@@ -1,28 +1,25 @@
-from django.core.urlresolvers import reverse
 from sentry.testutils import APITestCase
 
 
 class OrganizationUserDetailsTest(APITestCase):
+    endpoint = "sentry-api-0-organization-user-details"
+
     def setUp(self):
         self.owner_user = self.create_user("foo@localhost", username="foo")
         self.user = self.create_user("bar@localhost", username="bar")
 
         self.org = self.create_organization(owner=self.owner_user)
         self.member = self.create_member(organization=self.org, user=self.user)
-        self.url = reverse(
-            "sentry-api-0-organization-user-details", args=[self.org.slug, self.user.id]
-        )
 
-    def test_gets_info_for_user_in_org(self):
         self.login_as(user=self.owner_user)
-        response = self.client.get(self.url)
+
+    def test_gets_info_for_user_in_org(self):
+        response = self.get_valid_response(self.org.slug, self.user.id)
+
         assert response.data["id"] == str(self.user.id)
         assert response.data["email"] == self.user.email
 
     def test_cannot_access_info_if_user_not_in_org(self):
-        self.login_as(user=self.owner_user)
         user = self.create_user("meep@localhost", username="meep")
-        url = reverse("sentry-api-0-organization-user-details", args=[self.org.slug, user.id])
-        response = self.client.get(url)
 
-        assert response.status_code == 404
+        self.get_valid_response(self.org.slug, user.id, status_code=404)

tests/sentry/api/endpoints/test_organization_user_teams.py

@@ -1,9 +1,9 @@
-from django.core.urlresolvers import reverse
-
 from sentry.testutils import APITestCase
 
 
 class OrganizationUserTeamsTest(APITestCase):
+    endpoint = "sentry-api-0-organization-user-teams"
+
     def setUp(self):
         self.foo = self.create_user("foo@example.com")
         self.bar = self.create_user("bar@example.com", is_superuser=True)
@@ -16,15 +16,10 @@ class OrganizationUserTeamsTest(APITestCase):
         self.create_member(organization=self.org, user=self.foo, teams=[self.team1, self.team2])
         self.create_member(organization=self.org, user=self.bar, teams=[self.team2])
 
-        self.url = reverse(
-            "sentry-api-0-organization-user-teams", kwargs={"organization_slug": self.org.slug}
-        )
-
     def test_simple(self):
         self.login_as(user=self.foo)
 
-        response = self.client.get(self.url)
-        assert response.status_code == 200
+        response = self.get_valid_response(self.org.slug)
 
         # Verify that only teams that the user is a member of, are returned
         assert len(response.data) == 2
@@ -42,8 +37,7 @@ class OrganizationUserTeamsTest(APITestCase):
     def test_super_user(self):
         self.login_as(user=self.bar, superuser=True)
 
-        response = self.client.get(self.url)
-        assert response.status_code == 200
+        response = self.get_valid_response(self.org.slug)
 
         # Verify that all teams are returned
         assert len(response.data) == 3

tests/sentry/api/endpoints/test_project_filter_details.py

@@ -2,15 +2,21 @@ from sentry.testutils import APITestCase
 
 
 class ProjectFilterDetailsTest(APITestCase):
-    def test_put(self):
+    endpoint = "sentry-api-0-project-filters"
+    method = "put"
+
+    def setUp(self):
+        super().setUp()
         self.login_as(user=self.user)
+
+    def test_put(self):
         org = self.create_organization(name="baz", slug="1", owner=self.user)
         team = self.create_team(organization=org, name="foo", slug="foo")
         project = self.create_project(name="Bar", slug="bar", teams=[team])
-        url = f"/api/0/projects/{org.slug}/{project.slug}/filters/browser-extensions/"
 
         project.update_option("filters:browser-extensions", "0")
-        response = self.client.put(url, format="json", data={"active": True})
-        assert response.status_code == 201
+        self.get_valid_response(
+            org.slug, project.slug, "browser-extensions", active=True, status_code=201
+        )
 
         assert project.get_option("filters:browser-extensions") == "1"

tests/sentry/api/endpoints/test_project_filters.py

@@ -2,15 +2,18 @@ from sentry.testutils import APITestCase
 
 
 class ProjectFiltersTest(APITestCase):
-    def test_get(self):
+    endpoint = "sentry-api-0-project-filters"
+
+    def setUp(self):
+        super().setUp()
         self.login_as(user=self.user)
+
+    def test_get(self):
         org = self.create_organization(name="baz", slug="1", owner=self.user)
         team = self.create_team(organization=org, name="foo", slug="foo")
         project = self.create_project(name="Bar", slug="bar", teams=[team])
-        url = f"/api/0/projects/{org.slug}/{project.slug}/filters/"
 
         project.update_option("filters:browser-extension", "0")
-        response = self.client.get(url)
-        assert response.status_code == 200
+        response = self.get_valid_response(org.slug, project.slug)
 
         self.insta_snapshot(response.data)