udata 14.0.0__py3-none-any.whl → 14.5.1.dev6__py3-none-any.whl

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_dcat_commands.py

@@ -2,7 +2,7 @@ from udata.tests.api import PytestOnlyDBTestCase
 
 
 class ParseUrlCommandTest(PytestOnlyDBTestCase):
-    def test_parse_url(self, cli, requests_mock, caplog) -> None:
+    def test_parse_url(self, requests_mock, caplog) -> None:
         logs = []
 
         def mock_echo(message: str) -> None:
@@ -15,7 +15,7 @@ class ParseUrlCommandTest(PytestOnlyDBTestCase):
             requests_mock.get(mock_url, text=test_rdf_file.read())
             requests_mock.head(mock_url, text="sig.oreme.rdf")
         dataset_id = "0437a976-cff1-4fa6-807a-c23006df2f8f"
-        result = cli(
+        result = self.cli(
             "dcat",
             "parse-url",
             mock_url,

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(

udata/tests/test_legal_mails.py

@@ -0,0 +1,359 @@
+import pytest
+from flask import url_for
+
+from udata.core.dataservices.factories import DataserviceFactory
+from udata.core.dataset.factories import DatasetFactory
+from udata.core.discussions.factories import DiscussionFactory, MessageDiscussionFactory
+from udata.core.organization.factories import OrganizationFactory
+from udata.core.reuse.factories import ReuseFactory
+from udata.core.user.factories import AdminFactory, UserFactory
+from udata.tests.api import APITestCase
+from udata.tests.helpers import capture_mails
+
+
+class AdminMailsOnDeleteTest(APITestCase):
+    """Test admin mails are sent on delete when send_legal_notice=True and user is sysadmin"""
+
+    modules = []
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataset_delete_with_mail_as_admin(self):
+        """Admin deleting dataset with send_legal_notice=True should send email to owner"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == owner.email
+        assert "deletion" in mails[0].subject.lower()
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataset_delete_without_mail_as_admin(self):
+        """Admin deleting dataset without send_mail should not send email"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.dataset", dataset=dataset))
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataset_delete_with_mail_as_non_admin(self):
+        """Non-admin deleting their dataset with send_legal_notice=True should not send email"""
+        owner = self.login()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataset_delete_with_org_owner_sends_to_admins(self):
+        """Deleting org-owned dataset should send email to org admins"""
+        self.login(AdminFactory())
+        org_admin = UserFactory()
+        org = OrganizationFactory(members=[{"user": org_admin, "role": "admin"}])
+        dataset = DatasetFactory(organization=org)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == org_admin.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_reuse_delete_with_mail_as_admin(self):
+        """Admin deleting reuse with send_legal_notice=True should send email to owner"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        reuse = ReuseFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.reuse", reuse=reuse) + "?send_legal_notice=true")
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == owner.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_reuse_delete_without_mail_as_admin(self):
+        """Admin deleting reuse without send_mail should not send email"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        reuse = ReuseFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.reuse", reuse=reuse))
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataservice_delete_with_mail_as_admin(self):
+        """Admin deleting dataservice with send_legal_notice=True should send email to owner"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataservice = DataserviceFactory(owner=owner)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataservice", dataservice=dataservice) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == owner.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_organization_delete_with_mail_as_admin(self):
+        """Admin deleting organization with send_legal_notice=True should send email to org admins"""
+        self.login(AdminFactory())
+        org_admin = UserFactory()
+        org = OrganizationFactory(members=[{"user": org_admin, "role": "admin"}])
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.organization", org=org) + "?send_legal_notice=true")
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == org_admin.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_user_delete_with_legal_notice_skips_simple_notification(self):
+        """Admin deleting user with send_legal_notice=True automatically skips simple notification"""
+        self.login(AdminFactory())
+        user_to_delete = UserFactory()
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.user", user=user_to_delete) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        # Only legal notice mail, simple notification is automatically skipped
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == user_to_delete.email
+        # Verify it's the legal notice (with appeal info), not the simple notification
+        assert "Deletion of your" in mails[0].subject  # Legal notice subject
+        assert "contest this decision" in mails[0].body  # Legal notice contains appeal info
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_discussion_delete_with_mail_as_admin(self):
+        """Admin deleting discussion with send_legal_notice=True should send email to author"""
+        self.login(AdminFactory())
+        author = UserFactory()
+        dataset = DatasetFactory()
+        discussion = DiscussionFactory(subject=dataset, user=author)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.discussion", id=discussion.id) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == author.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_message_delete_with_mail_as_admin(self):
+        """Admin deleting message with send_legal_notice=True should send email to author"""
+        self.login(AdminFactory())
+        author = UserFactory()
+        message_author = UserFactory()
+        dataset = DatasetFactory()
+        discussion = DiscussionFactory(
+            subject=dataset,
+            user=author,
+            discussion=[
+                MessageDiscussionFactory(posted_by=author),
+                MessageDiscussionFactory(posted_by=message_author),
+            ],
+        )
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.discussion_comment", id=discussion.id, cidx=1)
+                + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 1
+        assert mails[0].recipients[0] == message_author.email
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataset_delete_without_owner_no_mail_sent(self):
+        """Deleting dataset without owner or organization should not send email"""
+        self.login(AdminFactory())
+        dataset = DatasetFactory(owner=None, organization=None)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_reuse_delete_without_owner_no_mail_sent(self):
+        """Deleting reuse without owner or organization should not send email"""
+        self.login(AdminFactory())
+        reuse = ReuseFactory(owner=None, organization=None)
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.reuse", reuse=reuse) + "?send_legal_notice=true")
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_dataservice_delete_without_owner_no_mail_sent(self):
+        """Deleting dataservice without owner or organization should not send email"""
+        self.login(AdminFactory())
+        dataservice = DataserviceFactory(owner=None, organization=None)
+
+        with capture_mails() as mails:
+            response = self.delete(
+                url_for("api.dataservice", dataservice=dataservice) + "?send_legal_notice=true"
+            )
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+    @pytest.mark.options(DEFAULT_LANGUAGE="en")
+    def test_organization_delete_without_admins_no_mail_sent(self):
+        """Deleting organization without admin members should not send email"""
+        self.login(AdminFactory())
+        editor = UserFactory()
+        org = OrganizationFactory(members=[{"user": editor, "role": "editor"}])
+
+        with capture_mails() as mails:
+            response = self.delete(url_for("api.organization", org=org) + "?send_legal_notice=true")
+
+        self.assertStatus(response, 204)
+        assert len(mails) == 0
+
+
+class MailContentVariantsTest(APITestCase):
+    """Test mail content varies based on settings"""
+
+    modules = []
+
+    @pytest.mark.options(
+        DEFAULT_LANGUAGE="en",
+        TERMS_OF_USE_URL="https://example.com/terms",
+        TERMS_OF_USE_DELETION_ARTICLE="5.1.2",
+        TELERECOURS_URL="https://telerecours.fr",
+    )
+    def test_mail_with_all_settings(self):
+        """Mail should contain terms of use reference and telerecours when all settings defined"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            self.delete(url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true")
+
+        assert len(mails) == 1
+        body = mails[0].body
+        assert "Our terms of use specify" in body
+        assert "5.1.2" in body
+        assert "Télérecours" in body
+
+    @pytest.mark.options(
+        DEFAULT_LANGUAGE="en",
+        TERMS_OF_USE_DELETION_ARTICLE=None,
+        TELERECOURS_URL=None,
+    )
+    def test_mail_without_settings(self):
+        """Mail should use generic text when settings are not defined"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            self.delete(url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true")
+
+        assert len(mails) == 1
+        body = mails[0].body
+        assert "Our terms of use specify" not in body
+        assert "Télérecours" not in body
+        assert "contacting us" in body
+
+    @pytest.mark.options(
+        DEFAULT_LANGUAGE="en",
+        TERMS_OF_USE_URL="https://example.com/terms",
+        TERMS_OF_USE_DELETION_ARTICLE="3.2",
+        TELERECOURS_URL=None,
+    )
+    def test_mail_with_terms_only(self):
+        """Mail should contain terms of use but generic appeal when only terms defined"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            self.delete(url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true")
+
+        assert len(mails) == 1
+        body = mails[0].body
+        assert "Our terms of use specify" in body
+        assert "3.2" in body
+        assert "Télérecours" not in body
+        assert "contacting us" in body
+
+    @pytest.mark.options(
+        DEFAULT_LANGUAGE="en",
+        TERMS_OF_USE_DELETION_ARTICLE=None,
+        TELERECOURS_URL="https://telerecours.fr",
+    )
+    def test_mail_with_telerecours_only(self):
+        """Mail should contain telerecours but generic terms when only telerecours defined"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            self.delete(url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true")
+
+        assert len(mails) == 1
+        body = mails[0].body
+        assert "Our terms of use specify" not in body
+        assert "Télérecours" in body
+        assert "contacting us" not in body
+
+    @pytest.mark.options(
+        DEFAULT_LANGUAGE="en",
+        TERMS_OF_USE_URL=None,
+        TERMS_OF_USE_DELETION_ARTICLE="5.1.2",
+        TELERECOURS_URL=None,
+    )
+    def test_mail_with_article_but_no_url(self):
+        """Mail should use generic terms when article is defined but URL is missing"""
+        self.login(AdminFactory())
+        owner = UserFactory()
+        dataset = DatasetFactory(owner=owner)
+
+        with capture_mails() as mails:
+            self.delete(url_for("api.dataset", dataset=dataset) + "?send_legal_notice=true")
+
+        assert len(mails) == 1
+        body = mails[0].body
+        assert "Our terms of use specify" not in body
+        assert "5.1.2" not in body