udata 12.0.2.dev16__py3-none-any.whl → 12.0.2.dev18__py3-none-any.whl

udata/tests/contact_point/test_contact_point_models.py

@@ -2,10 +2,10 @@ import pytest
 
 from udata.core.contact_point.factories import ContactPointFactory
 from udata.models import db
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.usefixtures("clean_db")
-class ContactPointTest:
+class ContactPointTest(PytestOnlyDBTestCase):
     def test_validate_contact_role_needs_email_or_contact_form(self):
         with pytest.raises(db.ValidationError):
             ContactPointFactory(role="contact", email=None, contact_form=None)

udata/tests/dataservice/test_csv_adapter.py

@@ -1,17 +1,14 @@
 from datetime import datetime
 
-import pytest
-
 from udata.core.dataservices.csv import DataserviceCsvAdapter
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.organization.factories import OrganizationFactory
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.frontend
-@pytest.mark.usefixtures("clean_db")
-class DataserviceCSVAdapterTest:
+class DataserviceCSVAdapterTest(PytestOnlyDBTestCase):
     def test_dataservices_csv_adapter(self):
         dataservice = DataserviceFactory(
             created_at=datetime(2022, 12, 31),

udata/tests/dataservice/test_dataservice_rdf.py

@@ -16,13 +16,11 @@ from udata.rdf import (
     HVD_LEGISLATION,
     TAG_TO_EU_HVD_CATEGORIES,
 )
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import assert200, assert_redirects
 
-pytestmark = pytest.mark.usefixtures("app")
 
-
-@pytest.mark.frontend
-class DataserviceToRdfTest:
+class DataserviceToRdfTest(PytestOnlyAPITestCase):
     def test_minimal(self):
         dataservice = DataserviceFactory.build()  # Does not have an URL
         d = dataservice_to_rdf(dataservice)
@@ -83,8 +81,7 @@ class DataserviceToRdfTest:
             assert distrib.value(DCATAP.applicableLegislation).identifier == URIRef(HVD_LEGISLATION)
 
 
-@pytest.mark.frontend
-class DataserviceRdfViewsTest:
+class DataserviceRdfViewsTest(PytestOnlyAPITestCase):
     def test_rdf_default_to_jsonld(self, client):
         dataservice = DataserviceFactory()
         expected = url_for("api.dataservice_rdf_format", dataservice=dataservice.id, _format="json")

udata/tests/dataservice/test_dataservice_tasks.py

@@ -1,47 +1,45 @@
-import pytest
-
 from udata.core.dataservices import tasks
 from udata.core.dataservices.models import Dataservice
 from udata.core.user.factories import UserFactory
 from udata.harvest.models import HarvestItem, HarvestJob
 from udata.harvest.tests.factories import HarvestJobFactory
 from udata.models import Discussion, Follow, Message, Transfer
+from udata.tests.api import PytestOnlyDBTestCase
 from udata.utils import faker
 
-pytestmark = pytest.mark.usefixtures("clean_db")
-
-
-def test_purge_dataservices():
-    dataservices = [
-        Dataservice.objects.create(
-            title="delete me", base_api_url="https://example.com/api", deleted_at="2016-01-01"
-        ),
-        Dataservice.objects.create(title="keep me", base_api_url="https://example.com/api"),
-    ]
-
-    user = UserFactory()
-    transfer = Transfer.objects.create(
-        owner=user,
-        recipient=user,
-        subject=dataservices[0],
-        comment="comment",
-    )
-
-    discussion = Discussion.objects.create(
-        subject=dataservices[0],
-        user=user,
-        title="test discussion",
-        discussion=[Message(content=faker.sentence(), posted_by=user)],
-    )
-
-    follower = Follow.objects.create(follower=user, following=dataservices[0])
-
-    HarvestJobFactory(items=[HarvestItem(dataservice=dataservices[0])])
-
-    tasks.purge_dataservices()
 
-    assert Dataservice.objects.count() == 1
-    assert Transfer.objects.filter(id=transfer.id).count() == 0
-    assert Discussion.objects.filter(id=discussion.id).count() == 0
-    assert Follow.objects.filter(id=follower.id).count() == 0
-    assert HarvestJob.objects.filter(items__dataservice=dataservices[0].id).count() == 0
+class DataserviceTasksTest(PytestOnlyDBTestCase):
+    def test_purge_dataservices(self):
+        dataservices = [
+            Dataservice.objects.create(
+                title="delete me", base_api_url="https://example.com/api", deleted_at="2016-01-01"
+            ),
+            Dataservice.objects.create(title="keep me", base_api_url="https://example.com/api"),
+        ]
+
+        user = UserFactory()
+        transfer = Transfer.objects.create(
+            owner=user,
+            recipient=user,
+            subject=dataservices[0],
+            comment="comment",
+        )
+
+        discussion = Discussion.objects.create(
+            subject=dataservices[0],
+            user=user,
+            title="test discussion",
+            discussion=[Message(content=faker.sentence(), posted_by=user)],
+        )
+
+        follower = Follow.objects.create(follower=user, following=dataservices[0])
+
+        HarvestJobFactory(items=[HarvestItem(dataservice=dataservices[0])])
+
+        tasks.purge_dataservices()
+
+        assert Dataservice.objects.count() == 1
+        assert Transfer.objects.filter(id=transfer.id).count() == 0
+        assert Discussion.objects.filter(id=discussion.id).count() == 0
+        assert Follow.objects.filter(id=follower.id).count() == 0
+        assert HarvestJob.objects.filter(items__dataservice=dataservices[0].id).count() == 0

udata/tests/dataset/test_csv_adapter.py

@@ -1,15 +1,12 @@
 from datetime import datetime, timedelta
 
-import pytest
-
 from udata.core.dataset.csv import DatasetCsvAdapter, ResourcesCsvAdapter
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.dataset.models import Dataset
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.frontend
-@pytest.mark.usefixtures("clean_db")
-class DatasetCSVAdapterTest:
+class DatasetCSVAdapterTest(PytestOnlyDBTestCase):
     def test_resources_csv_adapter(self):
         date_created = datetime(2022, 12, 31)
         date_modified = date_created + timedelta(days=1)

udata/tests/dataset/test_dataset_actions.py

@@ -1,13 +1,11 @@
-import pytest
-
 from udata.core.dataset.actions import archive
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.discussions.models import Discussion
 from udata.core.user.factories import UserFactory
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.usefixtures("clean_db")
-class DatasetActionsTest:
+class DatasetActionsTest(PytestOnlyDBTestCase):
     def test_dataset_archive(self, app):
         user = UserFactory()
         app.config["ARCHIVE_COMMENT_USER_ID"] = user.id

udata/tests/dataset/test_dataset_commands.py

@@ -1,12 +1,10 @@
 from tempfile import NamedTemporaryFile
 
-import pytest
-
 from udata.core.dataset.factories import DatasetFactory
+from udata.tests.api import PytestOnlyDBTestCase
 
 
-@pytest.mark.usefixtures("clean_db")
-class DatasetCommandTest:
+class DatasetCommandTest(PytestOnlyDBTestCase):
     def test_dataset_archive_one(self, cli):
         dataset = DatasetFactory()
 

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")