udata 14.0.3.dev1__py3-none-any.whl → 14.7.3.dev4__py3-none-any.whl

udata/tests/helpers.py

@@ -4,7 +4,7 @@ from datetime import timedelta
 from io import BytesIO
 from urllib.parse import parse_qs, urlparse
 
-import mock
+import pytest
 from flask import current_app, json
 from flask_security.babel import FsDomain
 from PIL import Image
@@ -12,6 +12,11 @@ from PIL import Image
 from udata.core.spatial.factories import GeoZoneFactory
 from udata.mail import mail_sent
 
+requires_search_service = pytest.mark.skipif(
+    not os.environ.get("UDATA_TEST_SEARCH_INTEGRATION"),
+    reason="Set UDATA_TEST_SEARCH_INTEGRATION=1 to run search integration tests",
+)
+
 
 def assert_equal_dates(datetime1, datetime2, limit=1):  # Seconds.
     """Lax date comparison, avoid comparing milliseconds and seconds."""
@@ -35,51 +40,50 @@ def assert_json_equal(first, second):
 
 
 @contextmanager
-def mock_signals(callback, *signals):
+def mock_signals(*signals):
     __tracebackhide__ = True
-    specs = []
 
-    def handler(sender, **kwargs):
-        pass
+    callbacks_by_signal = {}
+    calls_kwargs_by_signal = {}
 
-    for signal in signals:
-        m = mock.Mock(spec=handler)
-        signal.connect(m, weak=False)
-        specs.append((signal, m))
+    for requestSignal in signals:
+        # We capture requestSignal with a default argument
+        def callback(*args, requestSignal=requestSignal, **kwargs):
+            calls_kwargs_by_signal.setdefault(requestSignal, [])
+            calls_kwargs_by_signal[requestSignal].append(kwargs)
+
+        callbacks_by_signal[requestSignal] = callback
+        requestSignal.connect(callback, weak=False)
 
-    yield
+    yield calls_kwargs_by_signal
 
-    for signal, mock_handler in specs:
-        signal.disconnect(mock_handler)
-        signal_name = getattr(signal, "name", str(signal))
-        callback(signal_name, mock_handler)
+    for sig in signals:
+        sig.disconnect(callbacks_by_signal[sig])
 
 
 @contextmanager
 def assert_emit(*signals, assertions_callback=None):
     __tracebackhide__ = True
-    msg = 'Signal "{0}" should have been emitted'
 
-    def callback(name, handler):
-        assert handler.called, msg.format(name)
-        if assertions_callback is not None:
-            assertions_callback(handler.call_args)
-
-    with mock_signals(callback, *signals):
+    with mock_signals(*signals) as calls_kwargs_by_signal:
         yield
 
+    for signal in signals:
+        assert signal in calls_kwargs_by_signal, f'Signal "{signal}" should have been emitted'
+        if assertions_callback is not None:
+            for kwargs in calls_kwargs_by_signal[signal]:
+                assertions_callback(kwargs)
+
 
 @contextmanager
 def assert_not_emit(*signals):
     __tracebackhide__ = True
-    msg = 'Signal "{0}" should NOT have been emitted'
-
-    def callback(name, handler):
-        assert not handler.called, msg.format(name)
-
-    with mock_signals(callback, *signals):
+    with mock_signals(*signals) as calls_args_by_signal:
         yield
 
+    for signal in signals:
+        assert signal not in calls_args_by_signal, f'Signal "{signal}" should not have been emitted'
+
 
 @contextmanager
 def capture_mails():

udata/tests/organization/test_notifications.py

@@ -1,8 +1,11 @@
 from udata.core.organization.factories import OrganizationFactory
-from udata.core.organization.notifications import membership_request_notifications
+from udata.core.organization.notifications import (
+    membership_request_notifications,
+)
 from udata.core.user.factories import UserFactory
+from udata.features.notifications.models import Notification
 from udata.models import Member, MembershipRequest
-from udata.tests.api import PytestOnlyDBTestCase
+from udata.tests.api import DBTestCase, PytestOnlyDBTestCase
 from udata.tests.helpers import assert_equal_dates
 
 
@@ -27,3 +30,65 @@ class OrganizationNotificationsTest(PytestOnlyDBTestCase):
         assert details["user"]["id"] == applicant.id
         assert details["user"]["fullname"] == applicant.fullname
         assert details["user"]["avatar"] == str(applicant.avatar)
+
+
+class MembershipRequestNotificationTest(DBTestCase):
+    def test_notification_created_for_admins_only(self):
+        """Notifications are created for all admin users, not editors"""
+        admin1 = UserFactory()
+        admin2 = UserFactory()
+        editor = UserFactory()
+        applicant = UserFactory()
+        members = [
+            Member(user=editor, role="editor"),
+            Member(user=admin1, role="admin"),
+            Member(user=admin2, role="admin"),
+        ]
+        org = OrganizationFactory(members=members)
+
+        request = MembershipRequest(user=applicant, comment="test")
+        org.add_membership_request(request)
+
+        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.request_organization == org
+            assert notification.details.request_user == applicant
+            assert_equal_dates(notification.created_at, request.created)
+
+    def test_no_duplicate_notifications(self):
+        """Duplicate notifications are not created on subsequent saves"""
+        admin = UserFactory()
+        applicant = UserFactory()
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
+
+        request = MembershipRequest(user=applicant, comment="test")
+        org.add_membership_request(request)
+        org.add_membership_request(request)
+
+        assert Notification.objects.count() == 1
+
+    def test_multiple_requests_create_separate_notifications(self):
+        """Multiple requests from different users create separate notifications"""
+        admin = UserFactory()
+        applicant1 = UserFactory()
+        applicant2 = UserFactory()
+        org = OrganizationFactory(members=[Member(user=admin, role="admin")])
+
+        request1 = MembershipRequest(user=applicant1, comment="test 1")
+        org.add_membership_request(request1)
+
+        request2 = MembershipRequest(user=applicant2, comment="test 2")
+        org.add_membership_request(request2)
+
+        notifications = Notification.objects.all()
+        assert len(notifications) == 2
+
+        request_users = [notif.details.request_user for notif in notifications]
+        self.assertIn(applicant1, request_users)
+        self.assertIn(applicant2, request_users)

udata/tests/search/test_search_integration.py

@@ -0,0 +1,70 @@
+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
+
+
+@requires_search_service
+@pytest.mark.options(SEARCH_SERVICE_API_URL="http://localhost:5000/api/1/", AUTO_INDEX=True)
+class SearchIntegrationTest(APITestCase):
+    """Integration tests that require a running search-service and Elasticsearch."""
+
+    def test_dataset_fuzzy_search(self):
+        """
+        Test that Elasticsearch fuzzy search works.
+
+        A typo in the search query ("spectakulaire" instead of "spectaculaire")
+        should still find the dataset thanks to ES fuzzy matching.
+        """
+        DatasetFactory(title="Données spectaculaires sur les transports")
+
+        # Small delay to let ES index the document
+        time.sleep(1)
+
+        # Search with a typo - only ES fuzzy search can handle this
+        response = self.get("/api/2/datasets/search/?q=spectakulaire")
+        self.assert200(response)
+        assert response.json["total"] >= 1
+
+        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/site/test_site_csv_exports.py

@@ -7,6 +7,7 @@ from flask import url_for
 from udata.core import csv
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset import tasks as dataset_tasks
+from udata.core.dataset.constants import SPD
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.reuse.factories import ReuseFactory
@@ -25,7 +26,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -73,7 +73,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -99,6 +98,27 @@ class SiteCsvExportsTest(APITestCase):
             self.assertNotIn(str(dataset.id), ids)
         self.assertNotIn(str(hidden_dataset.id), ids)
 
+    def test_datasets_csv_with_badge_filter(self):
+        self.app.config["EXPORT_CSV_MODELS"] = []
+        dataset_with_badge = DatasetFactory(resources=[ResourceFactory()])
+        dataset_with_badge.add_badge(SPD)
+        dataset_without_badge = DatasetFactory(resources=[ResourceFactory()])
+
+        response = self.get(url_for("api.site_datasets_csv", badge=SPD))
+
+        self.assert200(response)
+
+        csvfile = StringIO(response.data.decode("utf8"))
+        reader = csv.get_reader(csvfile)
+        next(reader)  # skip header
+
+        rows = list(reader)
+        ids = [row[0] for row in rows]
+
+        self.assertEqual(len(rows), 1)
+        self.assertIn(str(dataset_with_badge.id), ids)
+        self.assertNotIn(str(dataset_without_badge.id), ids)
+
     def test_resources_csv(self):
         self.app.config["EXPORT_CSV_MODELS"] = []
         datasets = [
@@ -110,7 +130,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -164,7 +183,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -200,7 +218,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -245,7 +262,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -293,7 +309,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -332,7 +347,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -379,7 +393,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
@@ -424,7 +437,6 @@ class SiteCsvExportsTest(APITestCase):
 
         self.assert200(response)
         self.assertEqual(response.mimetype, "text/csv")
-        self.assertEqual(response.charset, "utf-8")
 
         csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)

udata/tests/test_activity.py

@@ -211,9 +211,9 @@ class AuditableTest(APITestCase):
             not_auditable="original",
         )
 
-        def check_signal_update(args):
+        def check_signal_update(kwargs):
             self.assertEqual(
-                args[1]["changed_fields"],
+                kwargs["changed_fields"],
                 [
                     "name",
                     "tags",
@@ -224,13 +224,13 @@ class AuditableTest(APITestCase):
                     "embedded_list.1.name",
                 ],
             )
-            self.assertEqual(args[1]["previous"]["name"], "fake")
-            self.assertEqual(args[1]["previous"]["tags"], ["some", "tags"])
-            self.assertEqual(args[1]["previous"]["some_date"], date(2020, 1, 1))
-            self.assertEqual(args[1]["previous"]["daterange_embedded.start"], date(2020, 1, 1))
-            self.assertEqual(args[1]["previous"]["daterange_embedded.end"], date(2020, 12, 31))
-            self.assertEqual(args[1]["previous"]["some_list"], ["some", "list"])
-            self.assertEqual(args[1]["previous"]["embedded_list.1.name"], "fake_embedded_1")
+            self.assertEqual(kwargs["previous"]["name"], "fake")
+            self.assertEqual(kwargs["previous"]["tags"], ["some", "tags"])
+            self.assertEqual(kwargs["previous"]["some_date"], date(2020, 1, 1))
+            self.assertEqual(kwargs["previous"]["daterange_embedded.start"], date(2020, 1, 1))
+            self.assertEqual(kwargs["previous"]["daterange_embedded.end"], date(2020, 12, 31))
+            self.assertEqual(kwargs["previous"]["some_list"], ["some", "list"])
+            self.assertEqual(kwargs["previous"]["embedded_list.1.name"], "fake_embedded_1")
 
         with assert_emit(FakeAuditableSubject.on_update, assertions_callback=check_signal_update):
             fake.name = "different"

udata/tests/test_api_fields.py

@@ -354,3 +354,13 @@ class ApplyPaginationTest(PytestOnlyDBTestCase):
             results: DBPaginator = Fake.apply_pagination(Fake.apply_sort_filters(Fake.objects))
             assert results.page_size == 5
             assert results.page == 3
+
+    def test_negative_page_size_returns_404(self, app) -> None:
+        """Negative page_size should return a 404 error."""
+        from werkzeug.exceptions import NotFound
+
+        FakeFactory()
+
+        with app.test_request_context("/foobar", query_string={"page": 1, "page_size": -5}):
+            with pytest.raises(NotFound):
+                Fake.apply_pagination(Fake.apply_sort_filters(Fake.objects))

udata/tests/test_discussions.py

@@ -142,11 +142,11 @@ class DiscussionsTest(APITestCase):
         with assert_not_emit(on_new_discussion):
             discussion_id = None
 
-            def check_signal(args):
+            def check_signal(kwargs):
                 self.assertIsNotNone(discussion_id)
                 self.assertIn(
-                    f"https://data.gouv.fr/datasets/{dataset.slug}/discussions/?discussion_id={discussion_id}",
-                    args[1]["message"],
+                    f"https://data.gouv.fr/datasets/{dataset.slug}/discussions?discussion_id={discussion_id}",
+                    kwargs["message"],
                 )
 
             with assert_emit(on_new_potential_spam, assertions_callback=check_signal):
@@ -620,8 +620,8 @@ class DiscussionsTest(APITestCase):
         self.login()
         with assert_not_emit(on_new_discussion_comment):
 
-            def check_signal(args):
-                self.assertIn(discussion.url_for(), args[1]["message"])
+            def check_signal(kwargs):
+                self.assertIn(discussion.url_for(), kwargs["message"])
 
             with assert_emit(on_new_potential_spam, assertions_callback=check_signal):
                 response = self.post(