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

udata/tests/dataset/test_dataset_rdf.py

@@ -5,9 +5,10 @@ import pytest
 import requests
 from flask import url_for
 from rdflib import BNode, Graph, Literal, Namespace, URIRef
-from rdflib.namespace import FOAF, RDF, RDFS
+from rdflib.namespace import FOAF, ORG, RDF, RDFS
 from rdflib.resource import Resource as RdfResource
 
+from udata.core.constants import HVD
 from udata.core.contact_point.factories import ContactPointFactory
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset.constants import UpdateFrequency
@@ -52,11 +53,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 +68,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)
@@ -167,8 +167,8 @@ class DatasetToRdfTest:
         d = dataset_to_rdf(dataset)
 
         contact_rdf = d.value(DCT.publisher)
-        assert contact_rdf.value(RDF.type).identifier == VCARD.Kind
-        assert contact_rdf.value(VCARD.fn) == Literal("Publisher Contact")
+        assert contact_rdf.value(RDF.type).identifier == FOAF.Agent
+        assert contact_rdf.value(FOAF.name) == Literal("Publisher Contact")
 
         org_rdf = d.value(GEODCAT.distributor)
         assert org_rdf.value(RDF.type).identifier == FOAF.Organization
@@ -332,6 +332,7 @@ class DatasetToRdfTest:
         dataset = DatasetFactory(
             resources=ResourceFactory.build_batch(3), tags=["hvd", "mobilite", "test"]
         )
+        dataset.add_badge(HVD)
         d = dataset_to_rdf(dataset)
 
         assert d.value(DCATAP.applicableLegislation).identifier == URIRef(HVD_LEGISLATION)
@@ -349,7 +350,9 @@ class DatasetToRdfTest:
         dataset = DatasetFactory(
             resources=ResourceFactory.build_batch(3), tags=["hvd", "mobilite", "test"]
         )
+        dataset.add_badge(HVD)
         dataservice = DataserviceFactory(datasets=[dataset], tags=["hvd"])
+        dataservice.add_badge(HVD)
         d = dataset_to_rdf(dataset)
         g = d.graph
 
@@ -367,8 +370,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()
@@ -516,6 +518,194 @@ class RdfToDatasetTest:
         assert isinstance(dataset, Dataset)
         assert dataset.harvest.modified_at is None
 
+    def test_contact_point_individual_vcard(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        contact = BNode()
+        g.add((contact, RDF.type, VCARD.Individual))
+        g.add((contact, VCARD.fn, Literal("foo")))
+        g.add((contact, VCARD.email, Literal("foo@example.com")))
+        g.add((node, DCAT.contactPoint, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "contact"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_individual_foaf(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        contact = BNode()
+        contact_name = Literal("foo")
+        contact_email = Literal("foo@example.com")
+        g.add((contact, RDF.type, FOAF.Person))
+        g.add((contact, FOAF.name, contact_name))
+        g.add((contact, FOAF.mbox, contact_email))
+        g.add((node, DCT.creator, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "creator"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_organization_vcard(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        contact = BNode()
+        g.add((contact, RDF.type, VCARD.Organization))
+        g.add((contact, VCARD.fn, Literal("foo")))
+        g.add((contact, VCARD.email, Literal("foo@example.com")))
+        g.add((node, DCAT.contactPoint, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "contact"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_organization_foaf(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        contact = BNode()
+        g.add((contact, RDF.type, FOAF.Organization))
+        g.add((contact, FOAF.name, Literal("foo")))
+        g.add((contact, FOAF.mbox, Literal("foo@example.com")))
+        g.add((node, DCT.creator, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "creator"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_organization_member_vcard(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        contact = BNode()
+        g.add((contact, RDF.type, VCARD.Organization))
+        g.add((contact, VCARD.fn, Literal("foo")))
+        g.add((contact, VCARD["organization-name"], Literal("bar")))
+        g.add((contact, VCARD.email, Literal("foo@example.com")))
+        g.add((node, DCAT.contactPoint, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "contact"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_organization_member_foaf(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        org = BNode()
+        g.add((org, RDF.type, FOAF.Organization))
+        g.add((org, FOAF.name, Literal("bar")))
+        g.add((org, FOAF.mbox, Literal("bar@example.com")))
+        contact = BNode()
+        g.add((contact, RDF.type, FOAF.Person))
+        g.add((contact, FOAF.name, Literal("foo")))
+        g.add((contact, FOAF.mbox, Literal("foo@example.com")))
+        g.add((contact, ORG.memberOf, org))
+        g.add((node, DCT.creator, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "creator"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
+    def test_contact_point_organization_member_foaf_no_mail(self):
+        g = Graph()
+        node = URIRef("https://test.org/dataset")
+        g.set((node, RDF.type, DCAT.Dataset))
+        g.set((node, DCT.identifier, Literal(faker.uuid4())))
+        g.set((node, DCT.title, Literal(faker.sentence())))
+
+        org = BNode()
+        g.add((org, RDF.type, FOAF.Organization))
+        g.add((org, FOAF.name, Literal("bar")))
+        # no organization email
+        contact = BNode()
+        g.add((contact, RDF.type, FOAF.Person))
+        g.add((contact, FOAF.name, Literal("foo")))
+        g.add((contact, FOAF.mbox, Literal("foo@example.com")))
+        g.add((contact, ORG.memberOf, org))
+        g.add((node, DCT.creator, contact))
+
+        # Dataset needs an owner/organization for contact_points_from_rdf() to work
+        d = DatasetFactory.build()
+        d.organization = OrganizationFactory(name="organization")
+
+        dataset = dataset_from_rdf(g, d)
+        dataset.validate()
+
+        assert len(dataset.contact_points) == 1
+        assert dataset.contact_points[0].role == "creator"
+        assert dataset.contact_points[0].name == "foo"
+        assert dataset.contact_points[0].email == "foo@example.com"
+
     def test_theme_and_tags(self):
         node = BNode()
         g = Graph()
@@ -1122,17 +1312,16 @@ 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")
+        expected = url_for("api.dataset_rdf_format", dataset=dataset.id, _format="json")
         response = client.get(url_for("api.dataset_rdf", dataset=dataset))
         assert_redirects(response, expected)
 
     def test_rdf_perform_content_negociation(self, client):
         dataset = DatasetFactory()
-        expected = url_for("api.dataset_rdf_format", dataset=dataset.id, format="xml")
+        expected = url_for("api.dataset_rdf_format", dataset=dataset.id, _format="xml")
         url = url_for("api.dataset_rdf", dataset=dataset)
         headers = {"accept": "application/xml"}
         response = client.get(url, headers=headers)
@@ -1150,7 +1339,7 @@ class DatasetRdfViewsTest:
     def test_dataset_rdf_json_ld(self, client):
         dataset = DatasetFactory()
         for fmt in "json", "jsonld":
-            url = url_for("api.dataset_rdf_format", dataset=dataset, format=fmt)
+            url = url_for("api.dataset_rdf_format", dataset=dataset, _format=fmt)
             response = client.get(url, headers={"Accept": "application/ld+json"})
             assert200(response)
             assert response.content_type == "application/ld+json"
@@ -1170,13 +1359,13 @@ class DatasetRdfViewsTest:
     )
     def test_dataset_rdf_formats(self, client, fmt, mime):
         dataset = DatasetFactory()
-        url = url_for("api.dataset_rdf_format", dataset=dataset, format=fmt)
+        url = url_for("api.dataset_rdf_format", dataset=dataset, _format=fmt)
         response = client.get(url, headers={"Accept": mime})
         assert200(response)
         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")