udata 14.5.1.dev9__py3-none-any.whl → 14.7.3.dev4__py3-none-any.whl

udata/tests/apiv2/test_dataservices.py

@@ -0,0 +1,14 @@
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.tests.api import APITestCase
+
+
+class DataserviceSearchAPIV2Test(APITestCase):
+    def test_dataservice_search_with_model_query_param(self):
+        """Searching dataservices with 'model' as query param should not crash.
+
+        Regression test for: TypeError: query() got multiple values for argument 'model'
+        """
+        DataserviceFactory.create_batch(3)
+
+        response = self.get("/api/2/dataservices/search/?model=malicious")
+        self.assert200(response)

udata/tests/apiv2/test_organizations.py

@@ -4,6 +4,15 @@ from udata.core.organization.factories import Member, OrganizationFactory
 from udata.tests.api import APITestCase
 
 
+class OrganizationSearchAPIV2Test(APITestCase):
+    def test_organization_search_with_model_query_param(self):
+        """Searching organizations with 'model' as query param should not crash."""
+        OrganizationFactory.create_batch(3)
+
+        response = self.get("/api/2/organizations/search/?model=malicious")
+        self.assert200(response)
+
+
 class OrganizationExtrasAPITest(APITestCase):
     def setUp(self):
         self.login()

udata/tests/apiv2/test_reuses.py

@@ -0,0 +1,11 @@
+from udata.core.reuse.factories import ReuseFactory
+from udata.tests.api import APITestCase
+
+
+class ReuseSearchAPIV2Test(APITestCase):
+    def test_reuse_search_with_model_query_param(self):
+        """Searching reuses with 'model' as query param should not crash."""
+        ReuseFactory.create_batch(3)
+
+        response = self.get("/api/2/reuses/search/?model=malicious")
+        self.assert200(response)

udata/tests/dataset/test_dataset_rdf.py

@@ -518,6 +518,22 @@ class RdfToDatasetTest(PytestOnlyDBTestCase):
         assert isinstance(dataset, Dataset)
         assert dataset.harvest.modified_at is None
 
+    def test_unparseable_modified_at(self):
+        """Regression test: template strings like {{modified:toISO}} should not crash parsing."""
+        node = BNode()
+        g = Graph()
+
+        g.add((node, RDF.type, DCAT.Dataset))
+        g.add((node, DCT.identifier, Literal(faker.uuid4())))
+        g.add((node, DCT.title, Literal(faker.sentence())))
+        g.add((node, DCT.modified, Literal("{{modified:toISO}}")))
+
+        dataset = dataset_from_rdf(g)
+        dataset.validate()
+
+        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")
@@ -864,6 +880,39 @@ class RdfToDatasetTest(PytestOnlyDBTestCase):
         assert resource.harvest.modified_at.date() == modified.date()
         assert resource.format == "csv"
 
+    def test_resource_future_modified_at(self):
+        node = BNode()
+        g = Graph()
+
+        modified = faker.future_datetime()
+
+        g.add((node, RDF.type, DCAT.Distribution))
+        g.add((node, DCT.title, Literal(faker.sentence())))
+        g.add((node, DCAT.downloadURL, Literal(faker.uri())))
+        g.add((node, DCT.modified, Literal(modified)))
+
+        resource = resource_from_rdf(g)
+        resource.validate()
+
+        assert isinstance(resource, Resource)
+        assert resource.harvest.modified_at is None
+
+    def test_resource_unparseable_modified_at(self):
+        """Regression test: template strings like {{modified:toISO}} should not crash parsing."""
+        node = BNode()
+        g = Graph()
+
+        g.add((node, RDF.type, DCAT.Distribution))
+        g.add((node, DCT.title, Literal(faker.sentence())))
+        g.add((node, DCAT.downloadURL, Literal(faker.uri())))
+        g.add((node, DCT.modified, Literal("{{modified:toISO}}")))
+
+        resource = resource_from_rdf(g)
+        resource.validate()
+
+        assert isinstance(resource, Resource)
+        assert resource.harvest.modified_at is None
+
     def test_download_url_over_access_url(self):
         node = BNode()
         g = Graph()

udata/tests/search/test_search_integration.py

@@ -3,6 +3,8 @@ import time
 import pytest
 
 from udata.core.dataset.factories import DatasetFactory
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.reuse.factories import VisibleReuseFactory
 from udata.tests.api import APITestCase
 from udata.tests.helpers import requires_search_service
 
@@ -31,3 +33,38 @@ class SearchIntegrationTest(APITestCase):
 
         titles = [d["title"] for d in response.json["data"]]
         assert "Données spectaculaires sur les transports" in titles
+
+    def test_reuse_search_with_organization_filter(self):
+        """
+        Regression test for: 500 Server Error when None values are passed to search service.
+
+        When searching reuses with only an organization filter, other params should not be
+        sent as literal 'None' strings (e.g. ?q=None&tag=None).
+        """
+        org = OrganizationFactory()
+        reuse = VisibleReuseFactory(organization=org)
+
+        time.sleep(1)
+
+        response = self.get(f"/api/2/reuses/search/?organization={org.id}")
+        self.assert200(response)
+        assert response.json["total"] >= 1
+        ids = [r["id"] for r in response.json["data"]]
+        assert str(reuse.id) in ids
+
+    def test_organization_search_with_query(self):
+        """
+        Regression test for: 500 Server Error when None values are passed to search service.
+
+        When searching organizations, other params should not be sent as literal
+        'None' strings (e.g. ?badge=None).
+        """
+        org = OrganizationFactory(name="Organisation Unique Test")
+
+        time.sleep(1)
+
+        response = self.get("/api/2/organizations/search/?q=unique")
+        self.assert200(response)
+        assert response.json["total"] >= 1
+        ids = [o["id"] for o in response.json["data"]]
+        assert str(org.id) in ids

udata/tests/test_transfer.py

@@ -10,11 +10,13 @@ from udata.core.user.factories import UserFactory
 from udata.core.user.metrics import (
     update_owner_metrics,  # noqa needed to register signals
 )
-from udata.features.transfer.actions import accept_transfer, request_transfer
+from udata.features.notifications.models import Notification
+from udata.features.transfer.actions import accept_transfer, refuse_transfer, request_transfer
 from udata.features.transfer.factories import TransferFactory
 from udata.features.transfer.notifications import transfer_request_notifications
 from udata.models import Member
-from udata.tests.api import PytestOnlyDBTestCase
+from udata.tests.api import DBTestCase, PytestOnlyDBTestCase
+from udata.tests.helpers import assert_equal_dates
 from udata.utils import faker
 
 
@@ -218,3 +220,180 @@ class TransferNotificationsTest(PytestOnlyDBTestCase):
             transfer = transfers[details["id"]]
             assert details["subject"]["class"] == "dataset"
             assert details["subject"]["id"] == transfer.subject.id
+
+
+class TransferRequestNotificationTest(DBTestCase):
+    def test_notification_created_for_user_recipient(self):
+        """Notification is created for user recipient when transfer is requested"""
+        owner = UserFactory()
+        recipient = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        transfer = request_transfer(dataset, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+
+        notification = notifications[0]
+        assert notification.user == recipient
+        assert notification.details.transfer_owner == owner
+        assert notification.details.transfer_recipient == recipient
+        assert notification.details.transfer_subject == dataset
+        assert_equal_dates(notification.created_at, transfer.created)
+
+    def test_notification_created_for_org_admins_only(self):
+        """Notifications are created for all admin users of recipient org, not editors"""
+        owner = UserFactory()
+        admin1 = UserFactory()
+        admin2 = UserFactory()
+        editor = UserFactory()
+        members = [
+            Member(user=editor, role="editor"),
+            Member(user=admin1, role="admin"),
+            Member(user=admin2, role="admin"),
+        ]
+        org = OrganizationFactory(members=members)
+        dataset = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        transfer = request_transfer(dataset, org, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 2
+
+        admin_users = [notif.user for notif in notifications]
+        self.assertIn(admin1, admin_users)
+        self.assertIn(admin2, admin_users)
+
+        for notification in notifications:
+            assert notification.details.transfer_owner == owner
+            assert notification.details.transfer_recipient == org
+            assert notification.details.transfer_subject == dataset
+            assert_equal_dates(notification.created_at, transfer.created)
+
+    def test_no_duplicate_notifications(self):
+        """Duplicate notifications are not created for same transfer"""
+        owner = UserFactory()
+        recipient = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        request_transfer(dataset, recipient, faker.sentence())
+        request_transfer(dataset, recipient, faker.sentence())
+
+        assert Notification.objects.count() == 1
+
+    def test_multiple_transfers_create_separate_notifications(self):
+        """Multiple transfer requests create separate notifications"""
+        owner = UserFactory()
+        recipient = UserFactory()
+        dataset1 = DatasetFactory(owner=owner)
+        dataset2 = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        request_transfer(dataset1, recipient, faker.sentence())
+        request_transfer(dataset2, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 2
+
+        subjects = [notif.details.transfer_subject for notif in notifications]
+        self.assertIn(dataset1, subjects)
+        self.assertIn(dataset2, subjects)
+
+    def test_notification_not_created_if_previous_exists(self):
+        """Notification is created when transferring from org to user"""
+        admin = UserFactory()
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
+        dataset = DatasetFactory(organization=org)
+        recipient = UserFactory()
+
+        login_user(admin)
+        request_transfer(dataset, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+
+        request_transfer(dataset, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+
+    def test_notification_created_if_previous_handled(self):
+        """Notification is created when transferring from org to user"""
+        admin = UserFactory()
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
+        dataset = DatasetFactory(organization=org)
+        recipient = UserFactory()
+
+        login_user(admin)
+        transfer = request_transfer(dataset, recipient, faker.sentence())
+
+        login_user(recipient)
+        refuse_transfer(transfer)
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+
+        login_user(admin)
+        request_transfer(dataset, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 2
+
+    def test_notification_created_for_org_to_user_transfer(self):
+        """Notification is created when transferring from org to user"""
+        admin = UserFactory()
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
+        dataset = DatasetFactory(organization=org)
+        recipient = UserFactory()
+
+        login_user(admin)
+        transfer = request_transfer(dataset, recipient, faker.sentence())
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+
+        notification = notifications[0]
+        assert notification.user == recipient
+        assert notification.details.transfer_owner == org
+        assert notification.details.transfer_recipient == recipient
+        assert notification.details.transfer_subject == dataset
+        assert_equal_dates(notification.created_at, transfer.created)
+
+    def test_notification_handled_when_transfer_accepted(self):
+        """Notification's handled_at is updated when transfer is accepted"""
+        owner = UserFactory()
+        recipient = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        # First create the notification by requesting the transfer
+        transfer = request_transfer(dataset, recipient, faker.sentence())
+        # Then accept the transfer
+        login_user(recipient)
+        accept_transfer(transfer)
+
+        # Check that the notification has been handled
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+        assert notifications[0].handled_at is not None
+
+    def test_notification_handled_when_transfer_refused(self):
+        """Notification's handled_at is updated when transfer is refused"""
+        owner = UserFactory()
+        recipient = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        login_user(owner)
+        # First create the notification by requesting the transfer
+        transfer = request_transfer(dataset, recipient, faker.sentence())
+        # Then refuse the transfer
+        login_user(recipient)
+        refuse_transfer(transfer)
+
+        # Check that the notification has been handled
+        notifications = Notification.objects.all()
+        assert len(notifications) == 1
+        assert notifications[0].handled_at is not None