udata 12.0.2.dev17__py3-none-any.whl → 12.0.2.dev19__py3-none-any.whl

udata/tests/dataset/test_dataset_events.py

@@ -7,12 +7,12 @@ from udata.core.dataset.events import serialize_resource_for_event
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.dataset.models import Schema
 from udata.models import Dataset
+from udata.tests.api import PytestOnlyDBTestCase
 from udata.tests.helpers import assert_emit
 
 
-@pytest.mark.usefixtures("clean_db")
-@pytest.mark.usefixtures("enable_resource_event")
-class DatasetEventsTest:
+@pytest.mark.options(PUBLISH_ON_RESOURCE_EVENTS=True, RESOURCES_ANALYSER_URI="http://local.dev")
+class DatasetEventsTest(PytestOnlyDBTestCase):
     @patch("requests.post")
     @pytest.mark.options(RESOURCES_ANALYSER_API_KEY=None)
     def test_publish_message_resource_created_no_api_key(self, mock_req):

udata/tests/dataset/test_dataset_model.py

@@ -37,13 +37,12 @@ from udata.core.followers.signals import on_follow, on_unfollow
 from udata.core.reuse.factories import ReuseFactory, VisibleReuseFactory
 from udata.core.user.factories import UserFactory
 from udata.models import Dataset, Follow, License, ResourceSchema, Reuse, Schema, db
+from udata.tests.api import PytestOnlyDBTestCase
 from udata.tests.helpers import assert_emit, assert_equal_dates, assert_not_emit
 from udata.utils import faker
 
-pytestmark = pytest.mark.usefixtures("clean_db")
 
-
-class DatasetModelTest:
+class DatasetModelTest(PytestOnlyDBTestCase):
     def test_add_resource(self):
         user = UserFactory()
         dataset = DatasetFactory(owner=user)
@@ -426,7 +425,7 @@ class DatasetModelTest:
         assert dataset.get_metrics()["dataservices"] == 0
 
 
-class ResourceModelTest:
+class ResourceModelTest(PytestOnlyDBTestCase):
     def test_url_is_required(self):
         with pytest.raises(db.ValidationError):
             DatasetFactory(resources=[ResourceFactory(url=None)])
@@ -451,7 +450,7 @@ class ResourceModelTest:
             resource.save(signal_kwargs={"ignores": ["post_save"]})
 
 
-class LicenseModelTest:
+class LicenseModelTest(PytestOnlyDBTestCase):
     @pytest.fixture(autouse=True)
     def setUp(self):
         # Feed the DB with random data to ensure true matching
@@ -672,7 +671,7 @@ class LicenseModelTest:
         assert license.id == found.id
 
 
-class ResourceSchemaTest:
+class ResourceSchemaTest(PytestOnlyDBTestCase):
     @pytest.mark.options(SCHEMA_CATALOG_URL="https://example.com/notfound")
     def test_resource_schema_objects_404_endpoint(self, rmock):
         rmock.get("https://example.com/notfound", status_code=404)
@@ -787,7 +786,7 @@ class ResourceSchemaTest:
             resource.schema.clean(check_schema_in_catalog=True)
 
 
-class HarvestMetadataTest:
+class HarvestMetadataTest(PytestOnlyDBTestCase):
     def test_harvest_dataset_metadata_validate_success(self):
         dataset = DatasetFactory()
 

udata/tests/dataset/test_dataset_rdf.py

@@ -52,11 +52,11 @@ from udata.rdf import (
     default_lang_value,
     primary_topic_identifier_from_rdf,
 )
+from udata.tests import PytestOnlyTestCase
+from udata.tests.api import PytestOnlyAPITestCase, PytestOnlyDBTestCase
 from udata.tests.helpers import assert200, assert_redirects
 from udata.utils import faker
 
-pytestmark = pytest.mark.usefixtures("app")
-
 GOV_UK_REF = "http://reference.data.gov.uk/id/year/2017"
 
 try:
@@ -67,8 +67,7 @@ else:
     GOV_UK_REF_IS_UP = True
 
 
-@pytest.mark.frontend
-class DatasetToRdfTest:
+class DatasetToRdfTest(PytestOnlyAPITestCase):
     def test_minimal(self):
         dataset = DatasetFactory.build()  # Does not have an URL
         d = dataset_to_rdf(dataset)
@@ -367,8 +366,7 @@ class DatasetToRdfTest:
         assert dataservice_as_distribution.value(DCAT.accessService).identifier == dataservice_uri
 
 
-@pytest.mark.usefixtures("clean_db")
-class RdfToDatasetTest:
+class RdfToDatasetTest(PytestOnlyDBTestCase):
     def test_minimal(self):
         node = BNode()
         g = Graph()
@@ -1122,8 +1120,7 @@ class RdfToDatasetTest:
         assert value.language == "es"
 
 
-@pytest.mark.frontend
-class DatasetRdfViewsTest:
+class DatasetRdfViewsTest(PytestOnlyAPITestCase):
     def test_rdf_default_to_jsonld(self, client):
         dataset = DatasetFactory()
         expected = url_for("api.dataset_rdf_format", dataset=dataset.id, _format="json")
@@ -1176,7 +1173,7 @@ class DatasetRdfViewsTest:
         assert response.content_type == mime
 
 
-class DatasetFromRdfUtilsTest:
+class DatasetFromRdfUtilsTest(PytestOnlyTestCase):
     def test_licenses_from_rdf(self):
         """Test a bunch of cases of licenses detection from RDF"""
         rdf_xml_data = """<?xml version="1.0" encoding="UTF-8"?>

udata/tests/dataset/test_dataset_recommendations.py

@@ -4,6 +4,7 @@ import pytest
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.dataset.recommendations import recommendations_add, recommendations_clean
 from udata.core.reuse.factories import ReuseFactory
+from udata.tests.api import PytestOnlyDBTestCase
 
 MOCK_URL = "http://reco.net"
 
@@ -64,8 +65,7 @@ def mock_response(datasets, reuses):
     ]
 
 
-@pytest.mark.usefixtures("clean_db")
-class DatasetRecommendationsTest:
+class DatasetRecommendationsTest(PytestOnlyDBTestCase):
     def test_clean(self):
         ds1 = DatasetFactory(
             extras={

udata/tests/dataset/test_dataset_tasks.py

@@ -16,71 +16,69 @@ from udata.harvest.csv import HarvestSourceCsvAdapter  # noqa
 from udata.harvest.models import HarvestItem, HarvestJob
 from udata.harvest.tests.factories import HarvestJobFactory
 from udata.models import CommunityResource, Dataset, Discussion, Follow, Topic, Transfer
-
-pytestmark = pytest.mark.usefixtures("clean_db")
-
-
-def test_purge_datasets():
-    datasets = [
-        Dataset.objects.create(title="delete me", deleted="2016-01-01"),
-        Dataset.objects.create(title="keep me"),
-    ]
-
-    topic = Topic.objects.create(name="test topic")
-    for d in datasets:
-        topic_element = TopicElement(element=d, topic=topic)
-        topic_element.save()
-
-    user = UserFactory()
-    transfer = Transfer.objects.create(
-        owner=user,
-        recipient=user,
-        subject=datasets[0],
-        comment="comment",
-    )
-
-    discussion = DiscussionFactory(subject=datasets[0])
-
-    follower = Follow.objects.create(follower=user, following=datasets[0])
-
-    HarvestJobFactory(items=[HarvestItem(dataset=datasets[0])])
-
-    Dataservice.objects.create(title="test", datasets=datasets)
-
-    tasks.purge_datasets()
-
-    assert Transfer.objects.filter(id=transfer.id).count() == 0
-
-    topic = Topic.objects(name="test topic").first()
-    topic_element = topic.elements.first()
-    assert topic_element.element is None
-
-    assert Discussion.objects.filter(id=discussion.id).count() == 0
-    assert Follow.objects.filter(id=follower.id).count() == 0
-    assert HarvestJob.objects.filter(items__dataset=datasets[0].id).count() == 0
-    assert Dataservice.objects.filter(datasets=datasets[0].id).count() == 0
-
-
-def test_purge_datasets_community():
-    dataset = Dataset.objects.create(title="delete me", deleted="2016-01-01")
-    community_resource1 = CommunityResourceFactory()
-    community_resource1.dataset = dataset
-    community_resource1.save()
-
-    tasks.purge_datasets()
-    assert CommunityResource.objects.count() == 0
-
-
-@pytest.mark.usefixtures("instance_path")
-def test_export_csv(app):
-    dataset = DatasetFactory()
-    app.config["EXPORT_CSV_DATASET_ID"] = dataset.id
-    models = app.config["EXPORT_CSV_MODELS"]
-    tasks.export_csv()
-    dataset = Dataset.objects.get(id=dataset.id)
-    assert len(dataset.resources) == len(models)
-    extras = [r.extras.get("csv-export:model") for r in dataset.resources]
-    for model in models:
-        assert model in extras
-    fs_filenames = [r.fs_filename for r in dataset.resources if r.url.endswith(r.fs_filename)]
-    assert len(fs_filenames) == len(dataset.resources)
+from udata.tests.api import PytestOnlyDBTestCase
+
+
+class DatasetTasksTest(PytestOnlyDBTestCase):
+    def test_purge_datasets(self):
+        datasets = [
+            Dataset.objects.create(title="delete me", deleted="2016-01-01"),
+            Dataset.objects.create(title="keep me"),
+        ]
+
+        topic = Topic.objects.create(name="test topic")
+        for d in datasets:
+            topic_element = TopicElement(element=d, topic=topic)
+            topic_element.save()
+
+        user = UserFactory()
+        transfer = Transfer.objects.create(
+            owner=user,
+            recipient=user,
+            subject=datasets[0],
+            comment="comment",
+        )
+
+        discussion = DiscussionFactory(subject=datasets[0])
+
+        follower = Follow.objects.create(follower=user, following=datasets[0])
+
+        HarvestJobFactory(items=[HarvestItem(dataset=datasets[0])])
+
+        Dataservice.objects.create(title="test", datasets=datasets)
+
+        tasks.purge_datasets()
+
+        assert Transfer.objects.filter(id=transfer.id).count() == 0
+
+        topic = Topic.objects(name="test topic").first()
+        topic_element = topic.elements.first()
+        assert topic_element.element is None
+
+        assert Discussion.objects.filter(id=discussion.id).count() == 0
+        assert Follow.objects.filter(id=follower.id).count() == 0
+        assert HarvestJob.objects.filter(items__dataset=datasets[0].id).count() == 0
+        assert Dataservice.objects.filter(datasets=datasets[0].id).count() == 0
+
+    def test_purge_datasets_community(self):
+        dataset = Dataset.objects.create(title="delete me", deleted="2016-01-01")
+        community_resource1 = CommunityResourceFactory()
+        community_resource1.dataset = dataset
+        community_resource1.save()
+
+        tasks.purge_datasets()
+        assert CommunityResource.objects.count() == 0
+
+    @pytest.mark.usefixtures("instance_path")
+    def test_export_csv(self, app):
+        dataset = DatasetFactory()
+        app.config["EXPORT_CSV_DATASET_ID"] = dataset.id
+        models = app.config["EXPORT_CSV_MODELS"]
+        tasks.export_csv()
+        dataset = Dataset.objects.get(id=dataset.id)
+        assert len(dataset.resources) == len(models)
+        extras = [r.extras.get("csv-export:model") for r in dataset.resources]
+        for model in models:
+            assert model in extras
+        fs_filenames = [r.fs_filename for r in dataset.resources if r.url.endswith(r.fs_filename)]
+        assert len(fs_filenames) == len(dataset.resources)

udata/tests/dataset/test_resource_preview.py

@@ -1,6 +1,7 @@
 import pytest
 
 from udata.core.dataset.factories import ResourceFactory
+from udata.tests.api import PytestOnlyAPITestCase
 
 DUMMY_EXTRAS = {
     "analysis:parsing:finished_at": "1987-12-23T10:55:00.000000+00:00",
@@ -8,62 +9,52 @@ DUMMY_EXTRAS = {
 }
 MAX_SIZE = 50000
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-    pytest.mark.options(PLUGINS=["tabular"]),
-    pytest.mark.frontend,
-]
 
+@pytest.mark.options(PLUGINS=["tabular"])
+class ResourcePreviewTest(PytestOnlyAPITestCase):
+    def expected_url(self, rid):
+        return "http://preview.me/resources/{0}".format(rid)
 
-def expected_url(rid):
-    return "http://preview.me/resources/{0}".format(rid)
+    @pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
+    def test_display_preview_for_tabular_resources(self):
+        resource = ResourceFactory(extras=DUMMY_EXTRAS)
+        assert resource.preview_url == self.expected_url(resource.id)
 
+    @pytest.mark.options(TABULAR_EXPLORE_URL=None)
+    def test_no_preview_if_no_conf(self):
+        assert ResourceFactory(extras=DUMMY_EXTRAS).preview_url is None
 
-@pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
-def test_display_preview_for_tabular_resources():
-    resource = ResourceFactory(extras=DUMMY_EXTRAS)
-    assert resource.preview_url == expected_url(resource.id)
+    @pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
+    def test_default_allow_remote_preview(self):
+        resources = [
+            ResourceFactory(extras=DUMMY_EXTRAS),
+            ResourceFactory(filetype="remote", extras=DUMMY_EXTRAS),
+        ]
 
+        for resource in resources:
+            assert resource.preview_url == self.expected_url(resource.id)
 
-@pytest.mark.options(TABULAR_EXPLORE_URL=None)
-def test_no_preview_if_no_conf():
-    assert ResourceFactory(extras=DUMMY_EXTRAS).preview_url is None
+    @pytest.mark.options(
+        TABULAR_EXPLORE_URL="http://preview.me",
+        TABULAR_ALLOW_REMOTE=False,
+    )
+    def test_allow_remote_preview_false(self):
+        local = ResourceFactory(extras=DUMMY_EXTRAS)
+        remote = ResourceFactory(filetype="remote", extras=DUMMY_EXTRAS)
 
+        assert local.preview_url == self.expected_url(local.id)
+        assert remote.preview_url is None
 
-@pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
-def test_default_allow_remote_preview():
-    resources = [
-        ResourceFactory(extras=DUMMY_EXTRAS),
-        ResourceFactory(filetype="remote", extras=DUMMY_EXTRAS),
-    ]
+    @pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
+    def test_display_preview_without_max_size(self):
+        resource = ResourceFactory(extras=DUMMY_EXTRAS, filesize=2 * MAX_SIZE)
 
-    for resource in resources:
-        assert resource.preview_url == expected_url(resource.id)
+        assert resource.preview_url == self.expected_url(resource.id)
 
+    @pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
+    def test_no_preview_if_no_parsing_table_info(self):
+        extras = DUMMY_EXTRAS
+        del extras["analysis:parsing:parsing_table"]
 
-@pytest.mark.options(
-    TABULAR_EXPLORE_URL="http://preview.me",
-    TABULAR_ALLOW_REMOTE=False,
-)
-def test_allow_remote_preview_false():
-    local = ResourceFactory(extras=DUMMY_EXTRAS)
-    remote = ResourceFactory(filetype="remote", extras=DUMMY_EXTRAS)
-
-    assert local.preview_url == expected_url(local.id)
-    assert remote.preview_url is None
-
-
-@pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
-def test_display_preview_without_max_size():
-    resource = ResourceFactory(extras=DUMMY_EXTRAS, filesize=2 * MAX_SIZE)
-
-    assert resource.preview_url == expected_url(resource.id)
-
-
-@pytest.mark.options(TABULAR_EXPLORE_URL="http://preview.me")
-def test_no_preview_if_no_parsing_table_info():
-    extras = DUMMY_EXTRAS
-    del extras["analysis:parsing:parsing_table"]
-
-    resource = ResourceFactory(extras=extras, filesize=2 * MAX_SIZE)
-    assert resource.preview_url is None
+        resource = ResourceFactory(extras=extras, filesize=2 * MAX_SIZE)
+        assert resource.preview_url is None

udata/tests/dataset/test_transport_tasks.py

@@ -3,6 +3,7 @@ import requests_mock
 
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.dataset.transport import clear_datasets, map_transport_datasets
+from udata.tests.api import PytestOnlyDBTestCase
 
 
 @pytest.fixture
@@ -25,8 +26,7 @@ def mock_response():
     ]
 
 
-@pytest.mark.usefixtures("clean_db")
-class TransportTasksTest:
+class TransportTasksTest(PytestOnlyDBTestCase):
     @pytest.mark.options(TRANSPORT_DATASETS_URL="http://local.test/api/datasets")
     def test_map_transport_datasets(self, mock_response):
         ds1 = DatasetFactory(id="61fd29da29ea95c7bc0e1211")

udata/tests/features/territories/__init__.py

@@ -1,5 +1,4 @@
 from udata.core.spatial.factories import GeoZoneFactory
-from udata.settings import Testing
 
 
 def create_geozones_fixtures():
@@ -19,8 +18,3 @@ def create_old_new_regions_fixtures():
         id="fr:region:76", level="fr:region", name="Languedoc-Rousillon et Midi-Pyrénées", code="76"
     )
     return lr, occitanie
-
-
-class TerritoriesSettings(Testing):
-    ACTIVATE_TERRITORIES = True
-    HANDLED_LEVELS = ("fr:commune", "fr:departement", "fr:region", "country")

udata/tests/features/territories/test_territories_api.py

@@ -1,18 +1,19 @@
+import pytest
 from flask import url_for
 
 from udata.core.spatial.factories import GeoZoneFactory
 from udata.tests.api import APITestCase
 from udata.tests.features.territories import (
-    TerritoriesSettings,
     create_geozones_fixtures,
     create_old_new_regions_fixtures,
 )
 
 
+@pytest.mark.options(
+    ACTIVATE_TERRITORIES=True,
+    HANDLED_LEVELS=("fr:commune", "fr:departement", "fr:region", "country"),
+)
 class TerritoriesAPITest(APITestCase):
-    modules = []
-    settings = TerritoriesSettings
-
     def setUp(self):
         self.paca, self.bdr, self.arles = create_geozones_fixtures()
 
@@ -21,15 +22,15 @@ class TerritoriesAPITest(APITestCase):
         self.assert400(response)
 
     def test_suggest_empty(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "tes"})
+        response = self.get(url_for("api.suggest_territory", q="tes"))
         self.assert200(response)
         self.assertEqual(response.json, [])
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "test"})
+        response = self.get(url_for("api.suggest_territory", q="test"))
         self.assert200(response)
         self.assertEqual(response.json, [])
 
     def test_suggest_town(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "arle"})
+        response = self.get(url_for("api.suggest_territory", q="arle"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["title"], self.arles.name)
@@ -37,7 +38,7 @@ class TerritoriesAPITest(APITestCase):
         self.assertIn("page", result)
 
     def test_suggest_town_five_letters(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "arles"})
+        response = self.get(url_for("api.suggest_territory", q="arles"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["title"], self.arles.name)
@@ -45,7 +46,7 @@ class TerritoriesAPITest(APITestCase):
         self.assertIn("page", result)
 
     def test_suggest_town_by_insee_code(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "13004"})
+        response = self.get(url_for("api.suggest_territory", q="13004"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["id"], self.arles.id)
@@ -55,7 +56,7 @@ class TerritoriesAPITest(APITestCase):
         arles_sur_tech = GeoZoneFactory(
             id="fr:commune:66009", level="fr:commune", name="Arles-sur-Tech", code="66009"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "arles"})
+        response = self.get(url_for("api.suggest_territory", q="arles"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 2)
@@ -64,7 +65,7 @@ class TerritoriesAPITest(APITestCase):
         self.assertEqual(results[1]["id"], arles_sur_tech.id)
 
     def test_suggest_county(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "bouche"})
+        response = self.get(url_for("api.suggest_territory", q="bouche"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["title"], self.bdr.name)
@@ -72,7 +73,7 @@ class TerritoriesAPITest(APITestCase):
         self.assertIn("page", result)
 
     def test_suggest_region(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "prov"})
+        response = self.get(url_for("api.suggest_territory", q="prov"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["title"], self.paca.name)
@@ -81,7 +82,7 @@ class TerritoriesAPITest(APITestCase):
 
     def test_suggest_old_new_region(self):
         lr, occitanie = create_old_new_regions_fixtures()
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "langue"})
+        response = self.get(url_for("api.suggest_territory", q="langue"))
         self.assert200(response)
         self.assertEqual(len(response.json), 2)
         result = response.json[0]
@@ -92,7 +93,7 @@ class TerritoriesAPITest(APITestCase):
         self.assertEqual(result["id"], lr.id)
 
     def test_suggest_county_by_id(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "13"})
+        response = self.get(url_for("api.suggest_territory", q="13"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["id"], self.bdr.id)
@@ -102,7 +103,7 @@ class TerritoriesAPITest(APITestCase):
         bouchet = GeoZoneFactory(
             id="fr:commune:26054", level="fr:commune", name="Bouchet", code="26054"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "bouche"})
+        response = self.get(url_for("api.suggest_territory", q="bouche"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 2)
@@ -114,7 +115,7 @@ class TerritoriesAPITest(APITestCase):
         guyane = GeoZoneFactory(
             id="fr:departement:973", level="fr:departement", name="Guyane", code="973"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "guya"})
+        response = self.get(url_for("api.suggest_territory", q="guya"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
@@ -124,7 +125,7 @@ class TerritoriesAPITest(APITestCase):
         guyane = GeoZoneFactory(
             id="fr:departement:973", level="fr:departement", name="Guyane", code="973"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "973"})
+        response = self.get(url_for("api.suggest_territory", q="973"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
@@ -134,7 +135,7 @@ class TerritoriesAPITest(APITestCase):
         bastia = GeoZoneFactory(
             id="fr:commune:2b033", level="fr:commune", name="Bastia", code="2b033"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "basti"})
+        response = self.get(url_for("api.suggest_territory", q="basti"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
@@ -144,7 +145,7 @@ class TerritoriesAPITest(APITestCase):
         bastia = GeoZoneFactory(
             id="fr:commune:2b033", level="fr:commune", name="Bastia", code="2b033"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "2b033"})
+        response = self.get(url_for("api.suggest_territory", q="2b033"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
@@ -154,7 +155,7 @@ class TerritoriesAPITest(APITestCase):
         haute_corse = GeoZoneFactory(
             id="fr:departement:2b", level="fr:departement", name="Haute-Corse", code="2b"
         )
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "2b"})
+        response = self.get(url_for("api.suggest_territory", q="2b"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
@@ -162,21 +163,21 @@ class TerritoriesAPITest(APITestCase):
 
     def test_not_suggest_country(self):
         GeoZoneFactory(id="country:fr", level="country", name="France")
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "fra"})
+        response = self.get(url_for("api.suggest_territory", q="fra"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "fran"})
+        response = self.get(url_for("api.suggest_territory", q="fran"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "franc"})
+        response = self.get(url_for("api.suggest_territory", q="franc"))
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
 
     def test_suggest_unicode(self):
-        response = self.get(url_for("api.suggest_territory"), qs={"q": "Bouches-du-Rhône"})
+        response = self.get(url_for("api.suggest_territory", q="Bouches-du-Rhône"))
         self.assert200(response)
         result = response.json[0]
         self.assertEqual(result["title"], self.bdr.name)

udata/tests/forms/test_current_user_field.py

@@ -9,11 +9,11 @@ from udata.core.user.factories import AdminFactory, UserFactory
 from udata.forms import ModelForm, fields
 from udata.i18n import gettext as _
 from udata.models import User, db
-from udata.tests import DBTestMixin, TestCase
+from udata.tests.api import DBTestCase
 from udata.tests.helpers import security_gettext
 
 
-class CurrentUserFieldTest(TestCase, DBTestMixin):
+class CurrentUserFieldTest(DBTestCase):
     def factory(self, *args, **kwargs):
         class Ownable(db.Document):
             owner = db.ReferenceField(User)

udata/tests/forms/test_dict_field.py

@@ -1,15 +1,13 @@
 from datetime import date, datetime
 
-import pytest
 from werkzeug.datastructures import MultiDict
 
 from udata.forms import ModelForm, fields
 from udata.mongo import db
+from udata.tests import PytestOnlyTestCase
 
-pytestmark = [pytest.mark.usefixtures("app")]
 
-
-class DictFieldTest:
+class DictFieldTest(PytestOnlyTestCase):
     def factory(self):
         class Fake(db.Document):
             raw = db.DictField()

udata/tests/forms/test_extras_fields.py

@@ -6,11 +6,10 @@ from werkzeug.datastructures import MultiDict
 
 from udata.forms import ModelForm, fields
 from udata.mongo import db
+from udata.tests import PytestOnlyTestCase
 
-pytestmark = [pytest.mark.usefixtures("app")]
 
-
-class ExtrasFieldTest:
+class ExtrasFieldTest(PytestOnlyTestCase):
     def factory(self):
         class Fake(db.Document):
             extras = db.ExtrasField()