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

udata/tests/api/test_activities_api.py

@@ -1,4 +1,3 @@
-import pytest
 from flask import url_for
 from werkzeug.test import TestResponse
 
@@ -11,12 +10,9 @@ from udata.core.topic.factories import TopicFactory
 from udata.core.topic.models import Topic
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.mongo import db
+from udata.tests.api import APITestCase
 from udata.tests.helpers import assert200, assert400
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-]
-
 
 class FakeDatasetActivity(Activity):
     key = "fakeDataset"
@@ -33,26 +29,24 @@ class FakeTopicActivity(Activity):
     related_to = db.ReferenceField(Topic, required=True)
 
 
-class ActivityAPITest:
-    modules = []
-
-    def test_activity_api_list(self, api) -> None:
+class ActivityAPITest(APITestCase):
+    def test_activity_api_list(self) -> None:
         """It should fetch an activity list from the API"""
         activities: list[Activity] = [
             FakeDatasetActivity.objects.create(actor=UserFactory(), related_to=DatasetFactory()),
             FakeReuseActivity.objects.create(actor=UserFactory(), related_to=ReuseFactory()),
         ]
 
-        response: TestResponse = api.get(url_for("api.activity"))
+        response: TestResponse = self.get(url_for("api.activity"))
         assert200(response)
         assert len(response.json["data"]) == len(activities)
 
-    def test_activity_api_list_filter_by_bogus_related_to(self, api) -> None:
+    def test_activity_api_list_filter_by_bogus_related_to(self) -> None:
         """It should return a 400 error if the `related_to` parameter isn't a valid ObjectId."""
-        response: TestResponse = api.get(url_for("api.activity", related_to="foobar"))
+        response: TestResponse = self.get(url_for("api.activity", related_to="foobar"))
         assert400(response)
 
-    def test_activity_api_list_filtered_by_related_to(self, api) -> None:
+    def test_activity_api_list_filtered_by_related_to(self) -> None:
         """It should only return activities that correspond to the `related_to` parameter."""
         dataset1: Dataset = DatasetFactory()
         dataset2: Dataset = DatasetFactory()
@@ -64,18 +58,18 @@ class ActivityAPITest:
             FakeReuseActivity.objects.create(actor=UserFactory(), related_to=reuse),
         ]
 
-        response: TestResponse = api.get(url_for("api.activity", related_to=dataset1.id))
+        response: TestResponse = self.get(url_for("api.activity", related_to=dataset1.id))
         assert200(response)
         len(response.json["data"]) == 2
         assert response.json["data"][0]["related_to"] == dataset1.title
         assert response.json["data"][1]["related_to"] == dataset1.title
 
-        response: TestResponse = api.get(url_for("api.activity", related_to=reuse.id))
+        response: TestResponse = self.get(url_for("api.activity", related_to=reuse.id))
         assert200(response)
         len(response.json["data"]) == 1
         assert response.json["data"][0]["related_to"] == reuse.title
 
-    def test_activity_api_list_with_private(self, api) -> None:
+    def test_activity_api_list_with_private(self) -> None:
         """It should fetch an activity list from the API"""
         activities: list[Activity] = [
             FakeDatasetActivity.objects.create(
@@ -87,28 +81,28 @@ class ActivityAPITest:
         ]
 
         # Anonymised user won't see activities about private documents
-        response: TestResponse = api.get(url_for("api.activity"))
+        response: TestResponse = self.get(url_for("api.activity"))
         assert200(response)
         assert len(response.json["data"]) == 0
 
         # Lambda user won't see activities about private documents
-        api.login()
-        response: TestResponse = api.get(url_for("api.activity"))
+        self.login()
+        response: TestResponse = self.get(url_for("api.activity"))
         assert200(response)
         assert len(response.json["data"]) == 0
 
         # Sysadmin user will see activities about private documents
-        api.login(AdminFactory())
-        response: TestResponse = api.get(url_for("api.activity"))
+        self.login(AdminFactory())
+        response: TestResponse = self.get(url_for("api.activity"))
         assert200(response)
         assert len(response.json["data"]) == len(activities)
 
-    def test_activity_api_with_topic(self, api) -> None:
+    def test_activity_api_with_topic(self) -> None:
         """It should fetch topic activities from the API"""
         topic: Topic = TopicFactory()
         FakeTopicActivity.objects.create(actor=UserFactory(), related_to=topic)
 
-        response: TestResponse = api.get(url_for("api.activity"))
+        response: TestResponse = self.get(url_for("api.activity"))
         assert200(response)
         assert len(response.json["data"]) == 1
 

udata/tests/api/test_auth_api.py

@@ -14,6 +14,7 @@ from udata.api.oauth2 import OAuth2Client, OAuth2Token
 from udata.auth import PermissionDenied
 from udata.core.user.factories import UserFactory
 from udata.forms import Form, fields, validators
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import (
     assert200,
     assert400,
@@ -65,10 +66,7 @@ def oauth(app, request):
     return OAuth2Client.objects.create(**kwargs)
 
 
-@pytest.mark.usefixtures("clean_db")
-class APIAuthTest:
-    modules = []
-
+class APIAuthTest(PytestOnlyAPITestCase):
     def test_no_auth(self, api):
         """Should not return a content type if there is no content on delete"""
         response = api.get(url_for("api.fake"))

udata/tests/api/test_contact_points.py

@@ -1,4 +1,3 @@
-import pytest
 from flask import url_for
 
 from udata.core.contact_point.factories import ContactPointFactory
@@ -7,17 +6,12 @@ from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Member
 from udata.i18n import gettext as _
 from udata.models import ContactPoint
+from udata.tests.api import APITestCase
 from udata.tests.helpers import assert200, assert201, assert204, assert400, assert403
 from udata.utils import faker
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-]
-
-
-class ContactPointAPITest:
-    modules = []
 
+class ContactPointAPITest(APITestCase):
     def test_get_or_create(self):
         org = OrganizationFactory()
         contact_point, created = ContactPoint.objects().get_or_create(
@@ -51,46 +45,46 @@ class ContactPointAPITest:
         assert created
         assert contact_point.name == "Another"
 
-    def test_contact_point_api_create(self, api):
-        user = api.login()
+    def test_contact_point_api_create(self):
+        user = self.login()
         data = {
             "name": faker.word(),
             "email": faker.email(),
             "contact_form": faker.url(),
             "role": "contact",
         }
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
         contact_point = ContactPoint.objects.first()
         assert contact_point.owner.id == user.id
 
-    def test_contact_point_api_create_email_or_contact_form(self, api):
-        api.login()
+    def test_contact_point_api_create_email_or_contact_form(self):
+        self.login()
         data = {"name": faker.word(), "contact_form": faker.url(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
         data = {"name": faker.word(), "email": faker.email(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 2
 
-    def test_contact_point_duplicate_creation(self, api):
-        api.login()
+    def test_contact_point_duplicate_creation(self):
+        self.login()
         data = {"name": faker.word(), "contact_form": faker.url(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
 
-    def test_contact_point_for_different_org(self, api):
-        user = api.login()
+    def test_contact_point_for_different_org(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org_a = OrganizationFactory(members=[member])
 
@@ -100,11 +94,11 @@ class ContactPointAPITest:
             "role": "contact",
             "organization": str(org_a.id),
         }
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
 
@@ -114,39 +108,39 @@ class ContactPointAPITest:
 
         org_b = OrganizationFactory(members=[])
         data["organization"] = str(org_b.id)
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert ContactPoint.objects.count() == 1
 
         org_b.members = [Member(user=user, role="editor")]
         org_b.save()
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 2
 
-    def test_contact_point_api_invalid_email(self, api):
-        api.login()
+    def test_contact_point_api_invalid_email(self):
+        self.login()
         data = {"name": faker.word(), "email": faker.word(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert "email" in response.json["errors"]
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_missing_contact_information(self, api):
-        api.login()
+    def test_contact_point_missing_contact_information(self):
+        self.login()
         data = {"name": faker.word(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert response.json["message"] == _(
             "At least an email or a contact form is required for a contact point"
         )
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_missing_role(self, api):
-        api.login()
+    def test_contact_point_missing_role(self):
+        self.login()
         data = {"name": faker.word(), "email": faker.email()}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert (
             response.json["message"]
@@ -154,70 +148,70 @@ class ContactPointAPITest:
         )
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_no_need_for_email_for_role_other_than_contact(self, api):
-        api.login()
+    def test_contact_point_no_need_for_email_for_role_other_than_contact(self):
+        self.login()
         roles_other_than_contact = [role_ for role_ in CONTACT_ROLES.keys() if role_ != "contact"]
         for index, role in enumerate(roles_other_than_contact):
             data = {"name": faker.word(), "role": role}
-            response = api.post(url_for("api.contact_points"), data=data)
+            response = self.post(url_for("api.contact_points"), data=data)
             assert201(response)
             assert ContactPoint.objects.count() == index + 1
 
-    def test_contact_point_api_update(self, api):
-        user = api.login()
+    def test_contact_point_api_update(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         contact_point = ContactPointFactory(organization=org)
         data = contact_point.to_dict()
         data["email"] = "new.email@newdomain.com"
-        response = api.put(url_for("api.contact_point", contact_point=contact_point), data)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point), data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
         assert ContactPoint.objects.first().email == "new.email@newdomain.com"
 
-    def test_contact_point_api_update_to_existing_contact_point(self, api):
-        user = api.login()
+    def test_contact_point_api_update_to_existing_contact_point(self):
+        user = self.login()
         contact_point_a = ContactPointFactory(email="a@example.org", owner=user)
         contact_point_b = ContactPointFactory(email="b@example.org", owner=user)
 
         data_b = contact_point_b.to_dict()
-        response = api.put(url_for("api.contact_point", contact_point=contact_point_a), data_b)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point_a), data_b)
         assert400(response)
         assert ContactPoint.objects.count() == 2
 
         contact_point_a.reload()
         assert contact_point_a.email == "a@example.org"
 
-    def test_contact_point_api_update_forbidden(self, api):
-        api.login()
+    def test_contact_point_api_update_forbidden(self):
+        self.login()
         org = OrganizationFactory()
         contact_point = ContactPointFactory(organization=org)
         data = contact_point.to_dict()
         data["email"] = "new.email@newdomain.com"
-        response = api.put(url_for("api.contact_point", contact_point=contact_point), data)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point), data)
         assert403(response)
         assert ContactPoint.objects.count() == 1
         assert ContactPoint.objects.first().email == contact_point.email
 
-    def test_contact_point_api_delete(self, api):
-        user = api.login()
+    def test_contact_point_api_delete(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         contact_point = ContactPointFactory(organization=org)
-        response = api.delete(url_for("api.contact_point", contact_point=contact_point))
+        response = self.delete(url_for("api.contact_point", contact_point=contact_point))
         assert204(response)
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_roles_list(self, api):
+    def test_contact_point_roles_list(self):
         """It should fetch the contact point roles list from the API"""
-        response = api.get(url_for("api.contact_point_roles"))
+        response = self.get(url_for("api.contact_point_roles"))
         assert200(response)
         assert len(response.json) == len(CONTACT_ROLES)
 
-    def test_contact_point_api_delete_forbidden(self, api):
-        api.login()
+    def test_contact_point_api_delete_forbidden(self):
+        self.login()
         org = OrganizationFactory()
         contact_point = ContactPointFactory(organization=org)
-        response = api.delete(url_for("api.contact_point", contact_point=contact_point))
+        response = self.delete(url_for("api.contact_point", contact_point=contact_point))
         assert403(response)
         assert ContactPoint.objects.count() == 1

udata/tests/api/test_dataservices_api.py

@@ -1,5 +1,4 @@
 from datetime import datetime, timedelta
-from xml.etree.ElementTree import XML
 
 import feedparser
 import pytest
@@ -7,24 +6,20 @@ from flask import url_for
 from werkzeug.test import TestResponse
 
 import udata.core.organization.constants as org_constants
-from udata.core.dataservices.constants import (
-    DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-    DATASERVICE_ACCESS_AUDIENCE_COMPANY,
-    DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
-    DATASERVICE_ACCESS_AUDIENCE_YES,
-    DATASERVICE_ACCESS_TYPE_OPEN,
-    DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
-    DATASERVICE_ACCESS_TYPE_RESTRICTED,
+from udata.core.access_type.constants import (
+    AccessAudienceCondition,
+    AccessAudienceType,
+    AccessType,
 )
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.factories import DatasetFactory, LicenseFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Member
-from udata.core.topic.factories import TopicElementFactory, TopicFactory
+from udata.core.topic.factories import ReuseFactory, TopicElementFactory, TopicFactory
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.i18n import gettext as _
-from udata.tests.helpers import assert200, assert400, assert410, assert_redirects
+from udata.tests.helpers import assert200, assert400, assert410
 
 from . import APITestCase
 
@@ -35,8 +30,6 @@ def dataservice_in_response(response: TestResponse, dataservice: Dataservice) ->
 
 
 class DataserviceAPITest(APITestCase):
-    modules = []
-
     def test_dataservice_api_get(self):
         """It should fetch a dataservice from the API"""
         dataservice = DataserviceFactory()
@@ -106,6 +99,34 @@ class DataserviceAPITest(APITestCase):
         assert len(response.json["data"]) == 1
         assert response.json["data"][0]["id"] == str(topic_dataservice.id)
 
+        # filter on reuse
+        reuse_dataservice = DataserviceFactory()
+        reuse = ReuseFactory(dataservices=[reuse_dataservice])
+        response = self.get(url_for("api.dataservices", reuse=reuse.id))
+        assert200(response)
+        assert len(response.json["data"]) == 1
+        assert response.json["data"][0]["id"] == str(reuse_dataservice.id)
+
+    def test_dataservices_topic_filter_errors(self):
+        # non-existing
+        response = self.get(url_for("api.dataservices", topic="690c7f48ec85adaa376c1e93"))
+        assert200(response)
+
+        # not an object ID
+        response = self.get(url_for("api.dataservices", topic="xxx"))
+        assert400(response)
+        assert "`topic` must be an identifier" in response.json["message"]
+
+    def test_dataservices_reuse_filter_errors(self):
+        # non-existing
+        response = self.get(url_for("api.dataservices", reuse="690c7f48ec85adaa376c1e93"))
+        assert200(response)
+
+        # not an object ID
+        response = self.get(url_for("api.dataservices", reuse="xxx"))
+        assert400(response)
+        assert "`reuse` must be an identifier" in response.json["message"]
+
     def test_dataservice_api_create(self):
         user = self.login()
         datasets = DatasetFactory.create_batch(3)
@@ -141,15 +162,15 @@ class DataserviceAPITest(APITestCase):
                 "extras": {
                     "foo": "bar",
                 },
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
                 "access_audiences": [
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
                     },
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_COMPANY,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                        "role": AccessAudienceType.COMPANY,
+                        "condition": AccessAudienceCondition.UNDER_CONDITIONS,
                     },
                 ],
             },
@@ -165,20 +186,18 @@ class DataserviceAPITest(APITestCase):
         self.assertEqual(
             response.json["self_api_url"], "http://local.test/api/1/dataservices/updated-title/"
         )
-        self.assertEqual(response.json["access_type"], DATASERVICE_ACCESS_TYPE_RESTRICTED)
+        self.assertEqual(response.json["access_type"], AccessType.RESTRICTED)
         self.assertEqual(len(response.json["access_audiences"]), 2)
         self.assertEqual(
-            response.json["access_audiences"][0]["role"], DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION
+            response.json["access_audiences"][0]["role"], AccessAudienceType.ADMINISTRATION
         )
         self.assertEqual(
-            response.json["access_audiences"][0]["condition"], DATASERVICE_ACCESS_AUDIENCE_YES
-        )
-        self.assertEqual(
-            response.json["access_audiences"][1]["role"], DATASERVICE_ACCESS_AUDIENCE_COMPANY
+            response.json["access_audiences"][0]["condition"], AccessAudienceCondition.YES
         )
+        self.assertEqual(response.json["access_audiences"][1]["role"], AccessAudienceType.COMPANY)
         self.assertEqual(
             response.json["access_audiences"][1]["condition"],
-            DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+            AccessAudienceCondition.UNDER_CONDITIONS,
         )
         # metadata_modified_at should have been updated during the patch
         self.assertNotEqual(
@@ -327,7 +346,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "B",
                 "base_api_url": "https://example.org/B",
                 "datasets": [dataset_b.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_OPEN,
+                "access_type": AccessType.OPEN,
             },
         )
         self.post(
@@ -336,7 +355,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "C",
                 "base_api_url": "https://example.org/C",
                 "datasets": [dataset_a.id, dataset_b.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
+                "access_type": AccessType.OPEN_WITH_ACCOUNT,
             },
         )
         self.post(
@@ -345,7 +364,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "A",
                 "base_api_url": "https://example.org/A",
                 "datasets": [dataset_a.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
             },
         )
         self.post(
@@ -408,7 +427,7 @@ class DataserviceAPITest(APITestCase):
         self.assertEqual(response.json["data"][0]["title"], "A")
         self.assertEqual(response.json["data"][1]["title"], "C")
 
-        response = self.get(url_for("api.dataservices", access_type=DATASERVICE_ACCESS_TYPE_OPEN))
+        response = self.get(url_for("api.dataservices", access_type=AccessType.OPEN))
         self.assert200(response)
 
         print(response.json)
@@ -599,15 +618,15 @@ class DataserviceAPITest(APITestCase):
             {
                 "title": "My title",
                 "base_api_url": "https://example.org",
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
                 "access_audiences": [
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
                     },
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.UNDER_CONDITIONS,
                     },
                 ],
             },
@@ -623,15 +642,15 @@ class DataserviceAPITest(APITestCase):
         dataservice = DataserviceFactory(owner=user, organization=original_org)
 
         data = dataservice.to_dict()
-        data["access_type"] = DATASERVICE_ACCESS_TYPE_RESTRICTED
+        data["access_type"] = AccessType.RESTRICTED
         data["access_audiences"] = [
             {
-                "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                "role": AccessAudienceType.ADMINISTRATION,
+                "condition": AccessAudienceCondition.YES,
             },
             {
-                "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                "role": AccessAudienceType.ADMINISTRATION,
+                "condition": AccessAudienceCondition.UNDER_CONDITIONS,
             },
         ]
         response = self.patch(url_for("api.dataservice", dataservice=dataservice), data)
@@ -664,62 +683,10 @@ class DataserviceAPITest(APITestCase):
         self.assertEqual(Dataservice.objects.first().organization.id, new_org.id)
 
 
-@pytest.mark.frontend
-class DataserviceRdfViewsTest:
-    def test_rdf_default_to_jsonld(self, client):
-        dataservice = DataserviceFactory()
-        expected = url_for("api.dataservice_rdf_format", dataservice=dataservice.id, format="json")
-        response = client.get(url_for("api.dataservice_rdf", dataservice=dataservice))
-        assert_redirects(response, expected)
-
-    def test_rdf_perform_content_negociation(self, client):
-        dataservice = DataserviceFactory()
-        expected = url_for("api.dataservice_rdf_format", dataservice=dataservice.id, format="xml")
-        url = url_for("api.dataservice_rdf", dataservice=dataservice)
-        headers = {"accept": "application/xml"}
-        response = client.get(url, headers=headers)
-        assert_redirects(response, expected)
-
-    def test_rdf_perform_content_negociation_response(self, client):
-        """Check we have valid XML as output"""
-        dataservice = DataserviceFactory()
-        url = url_for("api.dataservice_rdf", dataservice=dataservice)
-        headers = {"accept": "application/xml"}
-        response = client.get(url, headers=headers, follow_redirects=True)
-        element = XML(response.data)
-        assert element.tag == "{http://www.w3.org/1999/02/22-rdf-syntax-ns#}RDF"
-
-    def test_dataservice_rdf_json_ld(self, client):
-        dataservice = DataserviceFactory()
-        for fmt in "json", "jsonld":
-            url = url_for("api.dataservice_rdf_format", dataservice=dataservice, format=fmt)
-            response = client.get(url, headers={"Accept": "application/ld+json"})
-            assert200(response)
-            assert response.content_type == "application/ld+json"
-            assert response.json["@context"]["@vocab"] == "http://www.w3.org/ns/dcat#"
-
-    @pytest.mark.parametrize(
-        "fmt,mime",
-        [
-            ("n3", "text/n3"),
-            ("nt", "application/n-triples"),
-            ("ttl", "application/x-turtle"),
-            ("xml", "application/rdf+xml"),
-            ("rdf", "application/rdf+xml"),
-            ("owl", "application/rdf+xml"),
-            ("trig", "application/trig"),
-        ],
-    )
-    def test_dataservice_rdf_formats(self, client, fmt, mime):
-        dataservice = DataserviceFactory()
-        url = url_for("api.dataservice_rdf_format", dataservice=dataservice, format=fmt)
-        response = client.get(url, headers={"Accept": mime})
-        assert200(response)
-        assert response.content_type == mime
-
-
 class DataservicesFeedAPItest(APITestCase):
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=10)
     def test_recent_feed(self):
+        # We have a 10 hours delay for a new object to appear in feed. A newly created one shouldn't appear.
         DataserviceFactory(title="A", created_at=datetime.utcnow())
         DataserviceFactory(title="B", created_at=datetime.utcnow() - timedelta(days=2))
         DataserviceFactory(title="C", created_at=datetime.utcnow() - timedelta(days=1))
@@ -729,11 +696,11 @@ class DataservicesFeedAPItest(APITestCase):
 
         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), 2)
+        self.assertEqual(feed.entries[0].title, "C")
+        self.assertEqual(feed.entries[1].title, "B")
 
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
     def test_recent_feed_owner(self):
         owner = UserFactory()
         DataserviceFactory(owner=owner)
@@ -751,6 +718,7 @@ class DataservicesFeedAPItest(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()