udata 12.0.2.dev10__py3-none-any.whl → 13.0.1.dev21__py3-none-any.whl

udata/tests/api/test_datasets_api.py

@@ -15,6 +15,12 @@ from udata import uris
 from udata.api import fields
 from udata.app import cache
 from udata.core import storages
+from udata.core.access_type.constants import (
+    AccessAudienceCondition,
+    AccessAudienceType,
+    AccessType,
+    InspireLimitationCategory,
+)
 from udata.core.badges.factories import badge_factory
 from udata.core.dataset.constants import (
     DEFAULT_LICENSE,
@@ -36,17 +42,18 @@ from udata.core.dataset.models import (
     ResourceMixin,
 )
 from udata.core.organization.factories import OrganizationFactory
+from udata.core.organization.models import OrganizationBadge
 from udata.core.spatial.factories import GeoLevelFactory, SpatialCoverageFactory
 from udata.core.topic.factories import TopicElementDatasetFactory, TopicFactory
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.i18n import gettext as _
 from udata.models import CommunityResource, Dataset, Follow, Member, db
-from udata.tags import MAX_TAG_LENGTH, MIN_TAG_LENGTH
+from udata.tags import TAG_MAX_LENGTH, TAG_MIN_LENGTH
 from udata.tests.features.territories import create_geozones_fixtures
 from udata.tests.helpers import assert200, assert404
 from udata.utils import faker, unique_string
 
-from . import APITestCase
+from . import APITestCase, PytestOnlyAPITestCase
 
 SAMPLE_GEOM = {
     "type": "MultiPolygon",
@@ -66,8 +73,6 @@ def dataset_in_response(response: TestResponse, dataset: Dataset) -> bool:
 
 
 class DatasetAPITest(APITestCase):
-    modules = []
-
     def test_dataset_api_list(self):
         """It should fetch a dataset list from the API"""
         datasets = [DatasetFactory() for i in range(2)]
@@ -631,19 +636,21 @@ class DatasetAPITest(APITestCase):
         dataset = Dataset.objects.first()
         self.assertEqual(dataset.tags, sorted(data["tags"]))
 
+    @pytest.mark.options(TAG_MIN_LENGTH=3, TAG_MAX_LENGTH=10)
     def test_dataset_api_fail_to_create_too_short_tags(self):
         """It should fail to create a dataset from the API because
         the tag is too short"""
         data = DatasetFactory.as_dict()
-        data["tags"] = [unique_string(MIN_TAG_LENGTH - 1)]
+        data["tags"] = [unique_string(TAG_MIN_LENGTH - 1)]
         with self.api_user():
             response = self.post(url_for("api.datasets"), data)
         self.assertStatus(response, 400)
 
+    @pytest.mark.options(TAG_MIN_LENGTH=3, TAG_MAX_LENGTH=10)
     def test_dataset_api_fail_to_create_too_long_tags(self):
         """Should fail creating a dataset with a tag long"""
         data = DatasetFactory.as_dict()
-        data["tags"] = [unique_string(MAX_TAG_LENGTH + 1)]
+        data["tags"] = [unique_string(TAG_MAX_LENGTH + 1)]
         with self.api_user():
             response = self.post(url_for("api.datasets"), data)
         self.assertStatus(response, 400)
@@ -740,6 +747,18 @@ class DatasetAPITest(APITestCase):
         self.assertEqual(Dataset.objects.count(), 1)
         self.assertEqual(Dataset.objects.first().description, "new description")
 
+    def test_dataset_api_update_with_null_frequency(self):
+        """It should update the item even though internal frequency is null"""
+        user = self.login()
+        dataset = DatasetFactory(owner=user, frequency=None)
+        data = dataset.to_dict()
+        # Update doesn't matter as long as we don't touch `frequency`
+        data["tags"] = ["test"]
+        response = self.put(url_for("api.dataset", dataset=dataset), data)
+        self.assert200(response)
+        self.assertEqual(Dataset.objects.count(), 1)
+        self.assertEqual(Dataset.objects.first().frequency, None)
+
     def test_dataset_api_update_valid_frequency(self):
         """It should update a dataset from the API"""
         user = self.login()
@@ -1320,33 +1339,150 @@ class DatasetAPITest(APITestCase):
         assert dataset.resources[0].title == "updated 2"
         assert dataset.resources[0].schema is None
 
+    def test_add_access_type(self):
+        self.login(AdminFactory())
+        dataset = DatasetFactory()
+        assert dataset.access_type == AccessType.OPEN
+
+        response = self.get(url_for("api.dataset", dataset=dataset))
+
+        self.assert200(response)
+        assert response.json["access_type"] == AccessType.OPEN
+
+        response = self.put(
+            url_for("api.dataset", dataset=dataset),
+            {
+                "access_type": AccessType.RESTRICTED,
+                "access_audiences": [
+                    {
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
+                    },
+                    {"role": AccessAudienceType.COMPANY, "condition": AccessAudienceCondition.NO},
+                    {
+                        "role": AccessAudienceType.PRIVATE,
+                        "condition": AccessAudienceCondition.UNDER_CONDITIONS,
+                    },
+                ],
+                "authorization_request_url": "https://example.org",
+                "access_type_reason_category": InspireLimitationCategory.INTERNATIONAL_RELATIONS,
+                "access_type_reason": "Les données contiennent des information sensibles ou liées au secret défense",
+            },
+        )
+
+        self.assert200(response)
+        assert response.json["access_type"] == AccessType.RESTRICTED
+        assert (
+            response.json["access_type_reason_category"]
+            == InspireLimitationCategory.INTERNATIONAL_RELATIONS
+        )
+        assert (
+            response.json["access_type_reason"]
+            == "Les données contiennent des information sensibles ou liées au secret défense"
+        )
+        assert response.json["access_audiences"][0]["role"] == AccessAudienceType.ADMINISTRATION
+        assert response.json["access_audiences"][0]["condition"] == AccessAudienceCondition.YES
+        assert "id" not in response.json["access_audiences"][0]
+
+        dataset.reload()
+        assert dataset.access_type == AccessType.RESTRICTED
+        assert dataset.access_audiences[0].role == AccessAudienceType.ADMINISTRATION
+        assert dataset.access_audiences[0].condition == AccessAudienceCondition.YES
+        assert dataset.access_audiences[1].role == AccessAudienceType.COMPANY
+        assert dataset.access_audiences[1].condition == AccessAudienceCondition.NO
+        assert dataset.access_audiences[2].role == AccessAudienceType.PRIVATE
+        assert dataset.access_audiences[2].condition == AccessAudienceCondition.UNDER_CONDITIONS
+        assert dataset.authorization_request_url == "https://example.org"
+        assert (
+            dataset.access_type_reason_category == InspireLimitationCategory.INTERNATIONAL_RELATIONS
+        )
+        assert (
+            dataset.access_type_reason
+            == "Les données contiennent des information sensibles ou liées au secret défense"
+        )
+
+    def test_cannot_duplicate_access_audiences(self):
+        self.login(AdminFactory())
+        dataset = DatasetFactory()
+
+        response = self.put(
+            url_for("api.dataset", dataset=dataset),
+            {
+                "access_type": AccessType.RESTRICTED,
+                "access_audiences": [
+                    {
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
+                    },
+                    {
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
+                    },
+                ],
+            },
+        )
+
+        self.assert400(response)
+
+    def test_reset_license_on_restricted(self):
+        self.login(AdminFactory())
+        dataset = DatasetFactory(license=LicenseFactory(id="cc-by"))
+
+        response = self.put(
+            url_for("api.dataset", dataset=dataset),
+            {
+                "access_type": AccessType.RESTRICTED,
+            },
+        )
+
+        self.assert200(response)
+
+        dataset.reload()
+        assert dataset.license is None
+
 
 class DatasetsFeedAPItest(APITestCase):
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=10)
     def test_recent_feed(self):
+        certified_org = OrganizationFactory(badges=[OrganizationBadge(kind="certified")])
+        # We have a 10 hours delay for a new object to appear in feed. A newly created one shouldn't appear.
         DatasetFactory(
             title="A", resources=[ResourceFactory()], created_at_internal=datetime.utcnow()
         )
+        # Except in the case of a new dataset published by a certified organization
         DatasetFactory(
             title="B",
-            resources=[ResourceFactory()],
-            created_at_internal=datetime.utcnow() - timedelta(days=2),
+            created_at_internal=datetime.utcnow(),
+            organization=certified_org,
         )
         DatasetFactory(
             title="C",
-            resources=[ResourceFactory()],
+            created_at_internal=datetime.utcnow() - timedelta(days=2),
+        )
+        DatasetFactory(
+            title="D",
             created_at_internal=datetime.utcnow() - timedelta(days=1),
         )
+        # Even if dataset E is created more recently than D, it should appear after in the feed, since it doesn't have a delay
+        # before appearing in the field because it is published by a certified organization
+        DatasetFactory(
+            title="E",
+            created_at_internal=datetime.utcnow() - timedelta(hours=23),
+            organization=certified_org,
+        )
 
         response = self.get(url_for("api.recent_datasets_atom_feed"))
         self.assert200(response)
 
         feed = feedparser.parse(response.data)
 
-        self.assertEqual(len(feed.entries), 3)
-        self.assertEqual(feed.entries[0].title, "A")
-        self.assertEqual(feed.entries[1].title, "C")
-        self.assertEqual(feed.entries[2].title, "B")
+        self.assertEqual(len(feed.entries), 4)
+        self.assertEqual(feed.entries[0].title, "B")
+        self.assertEqual(feed.entries[1].title, "D")
+        self.assertEqual(feed.entries[2].title, "E")
+        self.assertEqual(feed.entries[3].title, "C")
 
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
     def test_recent_feed_owner(self):
         owner = UserFactory()
         DatasetFactory(owner=owner, resources=[ResourceFactory()])
@@ -1364,6 +1500,7 @@ class DatasetsFeedAPItest(APITestCase):
         self.assertEqual(author.name, owner.fullname)
         self.assertEqual(author.href, owner.url_for())
 
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
     def test_recent_feed_org(self):
         owner = UserFactory()
         org = OrganizationFactory()
@@ -1393,7 +1530,7 @@ class DatasetsFeedAPItest(APITestCase):
         assert "<h1>" in response.text
         assert "<ul>" in response.text
 
-    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0, CDATA_BASE_URL="http://example.org")
     def test_feed_id_uri_is_valid(self):
         DatasetFactory()
 
@@ -1473,8 +1610,6 @@ class DatasetBadgeAPITest(APITestCase):
 
 
 class DatasetResourceAPITest(APITestCase):
-    modules = None
-
     def setUp(self):
         self.login()
         self.dataset = DatasetFactory(owner=self.user)
@@ -1923,35 +2058,25 @@ class DatasetResourceAPITest(APITestCase):
         self.assertEqual(Follow.objects.following(user).count(), 0)
         self.assertEqual(Follow.objects.followers(user).count(), 0)
 
+    @pytest.mark.options(ALLOWED_RESOURCES_EXTENSIONS=["txt", "html", "kml", "kml-1", "qml", "xml"])
     def test_suggest_formats_api(self):
-        """It should suggest formats"""
-        DatasetFactory(
-            resources=[
-                ResourceFactory(format=f) for f in (faker.word(), faker.word(), "kml", "kml-1")
-            ]
-        )
-
-        response = self.get(url_for("api.suggest_formats"), qs={"q": "km", "size": "5"})
+        response = self.get(url_for("api.suggest_formats", q="km", size=5))
         self.assert200(response)
 
-        self.assertLessEqual(len(response.json), 5)
-        self.assertGreater(len(response.json), 1)
-
-        for suggestion in response.json:
-            self.assertIn("text", suggestion)
-            self.assertIn("km", suggestion["text"])
+        self.assertEqual(len(response.json), 2)
+        self.assertEqual(response.json[0]["text"], "kml")
+        self.assertEqual(response.json[1]["text"], "kml-1")
 
+    @pytest.mark.options(ALLOWED_RESOURCES_EXTENSIONS=["txt", "html", "kml", "kml-1", "qml", "xml"])
     def test_suggest_format_api_no_match(self):
-        """It should not provide format suggestion if no match"""
-        DatasetFactory(resources=[ResourceFactory(format=faker.word()) for _ in range(3)])
-
-        response = self.get(url_for("api.suggest_formats"), qs={"q": "test", "size": "5"})
+        response = self.get(url_for("api.suggest_formats", q="test", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
+    @pytest.mark.options(ALLOWED_RESOURCES_EXTENSIONS=[])
     def test_suggest_format_api_empty(self):
         """It should not provide format suggestion if no data"""
-        response = self.get(url_for("api.suggest_formats"), qs={"q": "test", "size": "5"})
+        response = self.get(url_for("api.suggest_formats", q="txt", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
@@ -1969,7 +2094,7 @@ class DatasetResourceAPITest(APITestCase):
             ]
         )
 
-        response = self.get(url_for("api.suggest_mime"), qs={"q": "js", "size": "5"})
+        response = self.get(url_for("api.suggest_mime", q="js", size=5))
         self.assert200(response)
         self.assertLessEqual(len(response.json), 5)
 
@@ -1980,7 +2105,7 @@ class DatasetResourceAPITest(APITestCase):
         """It should suggest mime types"""
         DatasetFactory(resources=[ResourceFactory(mime="application/xhtml+xml")])
 
-        response = self.get(url_for("api.suggest_mime"), qs={"q": "xml", "size": "5"})
+        response = self.get(url_for("api.suggest_mime", q="xml", size=5))
         self.assert200(response)
 
         self.assertEqual(len(response.json), 5)
@@ -1989,13 +2114,13 @@ class DatasetResourceAPITest(APITestCase):
         """It should not provide format suggestion if no match"""
         DatasetFactory(resources=[ResourceFactory(mime=faker.word()) for _ in range(3)])
 
-        response = self.get(url_for("api.suggest_mime"), qs={"q": "test", "size": "5"})
+        response = self.get(url_for("api.suggest_mime", q="test", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
     def test_suggest_mime_api_empty(self):
         """It should not provide mime suggestion if no data"""
-        response = self.get(url_for("api.suggest_mime"), qs={"q": "test", "size": "5"})
+        response = self.get(url_for("api.suggest_mime", q="test", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
@@ -2011,7 +2136,7 @@ class DatasetResourceAPITest(APITestCase):
             title="title-test-4", visible=True, metrics={"followers": 10}
         )
 
-        response = self.get(url_for("api.suggest_datasets"), qs={"q": "title-test", "size": "5"})
+        response = self.get(url_for("api.suggest_datasets", q="title-test", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -2034,7 +2159,7 @@ class DatasetResourceAPITest(APITestCase):
                 visible=True,
             )
 
-        response = self.get(url_for("api.suggest_datasets"), qs={"q": "acronym-test", "size": "5"})
+        response = self.get(url_for("api.suggest_datasets", q="acronym-test", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -2056,7 +2181,7 @@ class DatasetResourceAPITest(APITestCase):
                 resources=[ResourceFactory()],
             )
 
-        response = self.get(url_for("api.suggest_datasets"), qs={"q": "title-testé", "size": "5"})
+        response = self.get(url_for("api.suggest_datasets", q="title-testé", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -2074,13 +2199,13 @@ class DatasetResourceAPITest(APITestCase):
         for i in range(3):
             DatasetFactory(resources=[ResourceFactory()])
 
-        response = self.get(url_for("api.suggest_datasets"), qs={"q": "xxxxxx", "size": "5"})
+        response = self.get(url_for("api.suggest_datasets", q="xxxxxx", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
     def test_suggest_datasets_api_empty(self):
         """It should not provide dataset suggestion if no data"""
-        response = self.get(url_for("api.suggest_datasets"), qs={"q": "xxxxxx", "size": "5"})
+        response = self.get(url_for("api.suggest_datasets", q="xxxxxx", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
@@ -2110,8 +2235,6 @@ class DatasetReferencesAPITest(APITestCase):
 
 
 class DatasetArchivedAPITest(APITestCase):
-    modules = []
-
     def test_dataset_api_search_archived(self):
         """It should search datasets from the API, excluding archived ones"""
         DatasetFactory(archived=None)
@@ -2130,8 +2253,6 @@ class DatasetArchivedAPITest(APITestCase):
 
 
 class CommunityResourceAPITest(APITestCase):
-    modules = []
-
     def test_community_resource_api_get(self):
         """It should fetch a community resource from the API"""
         community_resource = CommunityResourceFactory()
@@ -2385,10 +2506,7 @@ class ResourcesTypesAPITest(APITestCase):
         self.assertEqual(len(response.json), len(RESOURCE_TYPES))
 
 
-@pytest.mark.usefixtures("clean_db")
-class DatasetSchemasAPITest:
-    modules = []
-
+class DatasetSchemasAPITest(PytestOnlyAPITestCase):
     def test_dataset_schemas_api_list(self, api, rmock, app):
         # Can't use @pytest.mark.options otherwise a request will be
         # made before setting up rmock at module load, resulting in a 404
@@ -2449,10 +2567,7 @@ class DatasetSchemasAPITest:
         )
 
 
-@pytest.mark.usefixtures("clean_db")
-class HarvestMetadataAPITest:
-    modules = []
-
+class HarvestMetadataAPITest(PytestOnlyAPITestCase):
     def test_dataset_with_harvest_metadata(self, api):
         date = datetime(2022, 2, 22, tzinfo=pytz.UTC)
         harvest_metadata = HarvestDatasetMetadata(

udata/tests/api/test_me_api.py

@@ -18,8 +18,6 @@ from . import APITestCase
 
 
 class MeAPITest(APITestCase):
-    modules = []
-
     def test_get_profile(self):
         """It should fetch my user data on GET"""
         self.login()
@@ -105,7 +103,7 @@ class MeAPITest(APITestCase):
         DatasetFactory(owner=user)
         DatasetFactory(organization=organization)
 
-        response = self.get(url_for("api.my_org_datasets"), qs={"q": "foô"})
+        response = self.get(url_for("api.my_org_datasets", q="foô"))
         self.assert200(response)
         self.assertEqual(len(response.json), len(datasets) + len(org_datasets))
 
@@ -139,7 +137,7 @@ class MeAPITest(APITestCase):
         CommunityResourceFactory(owner=user)
         CommunityResourceFactory(organization=organization)
 
-        response = self.get(url_for("api.my_org_community_resources"), qs={"q": "foô"})
+        response = self.get(url_for("api.my_org_community_resources", q="foô"))
         self.assert200(response)
         self.assertEqual(
             len(response.json), len(community_resources) + len(org_community_resources)
@@ -171,7 +169,7 @@ class MeAPITest(APITestCase):
         ReuseFactory(owner=user)
         ReuseFactory(organization=organization)
 
-        response = self.get(url_for("api.my_org_reuses"), qs={"q": "foô"})
+        response = self.get(url_for("api.my_org_reuses", q="foô"))
         self.assert200(response)
         self.assertEqual(len(response.json), len(reuses) + len(org_reuses))
 
@@ -221,7 +219,7 @@ class MeAPITest(APITestCase):
         Discussion.objects.create(subject=DatasetFactory(), title="foô", user=user)
         Discussion.objects.create(subject=ReuseFactory(), title="foô", user=user)
 
-        response = self.get(url_for("api.my_org_discussions"), qs={"q": "foô"})
+        response = self.get(url_for("api.my_org_discussions", q="foô"))
         self.assert200(response)
         self.assertEqual(len(response.json), len(discussions))
 

udata/tests/api/test_organizations_api.py

@@ -16,6 +16,7 @@ from udata.core.reuse.factories import ReuseFactory
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.i18n import _
 from udata.models import Discussion, Follow, Member, MembershipRequest, Organization
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import (
     assert200,
     assert201,
@@ -31,14 +32,8 @@ from udata.tests.helpers import (
 )
 from udata.utils import faker
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-]
-
-
-class OrganizationAPITest:
-    modules = []
 
+class OrganizationAPITest(PytestOnlyAPITestCase):
     def test_organization_api_list(self, api):
         """It should fetch an organization list from the API"""
         organizations = OrganizationFactory.create_batch(3)
@@ -235,9 +230,7 @@ class OrganizationAPITest:
         assert Organization.objects[0].deleted is None
 
 
-class MembershipAPITest:
-    modules = []
-
+class MembershipAPITest(PytestOnlyAPITestCase):
     def test_request_membership(self, api):
         organization = OrganizationFactory()
         user = api.login()
@@ -678,7 +671,7 @@ class MembershipAPITest:
                 name="test-{0}".format(i) if i % 2 else faker.word(), metrics={"followers": i}
             )
         max_follower_organization = OrganizationFactory(name="test-4", metrics={"followers": 10})
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "tes", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="tes", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -698,7 +691,7 @@ class MembershipAPITest:
         for i in range(4):
             OrganizationFactory(name="testé-{0}".format(i) if i % 2 else faker.word())
 
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "testé", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="testé", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -716,7 +709,7 @@ class MembershipAPITest:
         for i in range(4):
             OrganizationFactory(name="mon testé-{0}".format(i) if i % 2 else faker.word())
 
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "mon testé", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="mon testé", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -736,7 +729,7 @@ class MembershipAPITest:
                 name="Ministère de l'intérieur {0}".format(i) if i % 2 else faker.word()
             )
 
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "Ministère", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="Ministère", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -753,13 +746,13 @@ class MembershipAPITest:
         """It should not provide organization suggestion if no match"""
         OrganizationFactory.create_batch(3)
 
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "xxxxxx", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="xxxxxx", size=5))
         assert200(response)
         assert len(response.json) == 0
 
     def test_suggest_organizations_api_empty(self, api):
         """It should not provide organization suggestion if no data"""
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "xxxxxx", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="xxxxxx", size=5))
         assert200(response)
         assert len(response.json) == 0
 
@@ -767,7 +760,7 @@ class MembershipAPITest:
         """It should suggest organizations and not deduplicate homonyms"""
         OrganizationFactory.create_batch(2, name="homonym")
 
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "homonym", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="homonym", size=5))
         assert200(response)
 
         assert len(response.json) == 2
@@ -787,7 +780,7 @@ class MembershipAPITest:
         max_follower_organization = OrganizationFactory(
             name=faker.word(), acronym="UDATA4", metrics={"followers": 10}
         )
-        response = api.get(url_for("api.suggest_organizations"), qs={"q": "uDaTa", "size": "5"})
+        response = api.get(url_for("api.suggest_organizations", q="uDaTa", size=5))
         assert200(response)
 
         assert len(response.json) == 2
@@ -802,9 +795,7 @@ class MembershipAPITest:
             assert response.json[0]["id"] == str(max_follower_organization.id)
 
 
-class OrganizationDatasetsAPITest:
-    modules = []
-
+class OrganizationDatasetsAPITest(PytestOnlyAPITestCase):
     def test_list_org_datasets(self, api):
         """Should list organization datasets"""
         org = OrganizationFactory()
@@ -843,15 +834,13 @@ class OrganizationDatasetsAPITest:
         org = OrganizationFactory()
         DatasetFactory.create_batch(3, organization=org)
 
-        response = api.get(url_for("api.org_datasets", org=org), qs={"page_size": 2})
+        response = api.get(url_for("api.org_datasets", org=org, page_size=2))
 
         assert200(response)
         assert len(response.json["data"]) == 2
 
 
-class OrganizationReusesAPITest:
-    modules = []
-
+class OrganizationReusesAPITest(PytestOnlyAPITestCase):
     def test_list_org_reuses(self, api):
         """Should list organization reuses"""
         org = OrganizationFactory()
@@ -886,9 +875,7 @@ class OrganizationReusesAPITest:
         assert len(response.json) == len(reuses)
 
 
-class OrganizationDiscussionsAPITest:
-    modules = []
-
+class OrganizationDiscussionsAPITest(PytestOnlyAPITestCase):
     def test_list_org_discussions(self, api):
         """Should list organization discussions"""
         user = UserFactory()
@@ -910,11 +897,9 @@ class OrganizationDiscussionsAPITest:
             assert discussion["id"] in discussions_ids
 
 
-class OrganizationBadgeAPITest:
-    modules = []
-
+class OrganizationBadgeAPITest(PytestOnlyAPITestCase):
     @pytest.fixture(autouse=True)
-    def setUp(self, api, clean_db):
+    def setup_func(self, api):
         self.factory = badge_factory(Organization)
         self.user = api.login(AdminFactory())
         self.organization = OrganizationFactory()
@@ -978,9 +963,7 @@ class OrganizationBadgeAPITest:
         assert404(response)
 
 
-class OrganizationContactPointsAPITest:
-    modules = []
-
+class OrganizationContactPointsAPITest(PytestOnlyAPITestCase):
     def test_org_contact_points(self, api):
         user = api.login()
         member = Member(user=user, role="admin")
@@ -1027,9 +1010,7 @@ class OrganizationContactPointsAPITest:
         assert len(response.json) == 0
 
 
-class OrganizationCsvExportsTest:
-    modules = []
-
+class OrganizationCsvExportsTest(PytestOnlyAPITestCase):
     def test_datasets_csv(self, api):
         org = OrganizationFactory()
         [DatasetFactory(organization=org, resources=[ResourceFactory()]) for _ in range(3)]

udata/tests/api/test_reports_api.py

@@ -15,8 +15,6 @@ from . import APITestCase
 
 
 class ReportsReasonsAPITest(APITestCase):
-    modules = []
-
     def test_reports_reasons_api(self):
         response = self.get(url_for("api.reports_reasons"))
         self.assert200(response)
@@ -24,8 +22,6 @@ class ReportsReasonsAPITest(APITestCase):
 
 
 class ReportsAPITest(APITestCase):
-    modules = []
-
     def test_reports_api_create(self):
         user = UserFactory()