udata 13.0.1.dev12__py3-none-any.whl → 14.4.1.dev7__py3-none-any.whl

udata/tests/helpers.py

@@ -4,11 +4,11 @@ from datetime import timedelta
 from io import BytesIO
 from urllib.parse import parse_qs, urlparse
 
-import mock
 from flask import current_app, json
 from flask_security.babel import FsDomain
 from PIL import Image
 
+from udata.core.spatial.factories import GeoZoneFactory
 from udata.mail import mail_sent
 
 
@@ -34,51 +34,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():
@@ -221,5 +220,16 @@ def create_test_image():
     return file
 
 
+def create_geozones_fixtures():
+    paca = GeoZoneFactory(
+        id="fr:region:93", level="fr:region", name="Provence Alpes Côtes dAzur", code="93"
+    )
+    bdr = GeoZoneFactory(
+        id="fr:departement:13", level="fr:departement", name="Bouches-du-Rhône", code="13"
+    )
+    arles = GeoZoneFactory(id="fr:commune:13004", level="fr:commune", name="Arles", code="13004")
+    return paca, bdr, arles
+
+
 def security_gettext(string):
     return FsDomain(current_app).gettext(string)

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/plugin.py

@@ -1,147 +1,20 @@
-import shlex
-from contextlib import contextmanager
-
 import pytest
-from flask import current_app, json, template_rendered, url_for
-from flask.testing import FlaskClient
-from flask_principal import Identity, identity_changed
-from lxml import etree
-
-from udata.core.user.factories import UserFactory
-
-from .helpers import assert200, assert_command_ok
-
-
-class TestClient(FlaskClient):
-    """
-    The goal of these `post`, `put` and `delete` functions is to
-    switch from `data` in kwargs to `data` in args and be able to
-    `client.post(url, data)` without doing `client.post(url, data=data)`
-
-    Same as in :TestClientOverride
-    """
-
-    def post(self, url, data=None, **kwargs):
-        return super(TestClient, self).post(url, data=data, **kwargs)
-
-    def put(self, url, data=None, **kwargs):
-        return super(TestClient, self).put(url, data=data, **kwargs)
-
-    def delete(self, url, data=None, **kwargs):
-        return super(TestClient, self).delete(url, data=data, **kwargs)
-
-    def login(self, user=None):
-        user = user or UserFactory()
-        with self.session_transaction() as session:
-            # Since flask-security-too 4.0.0, the user.fs_uniquifier is used instead of user.id for auth
-            user_id = getattr(user, current_app.login_manager.id_attribute)()
-            session["user_id"] = user_id
-            session["_fresh"] = True
-            session["_id"] = current_app.login_manager._session_identifier_generator()
-            current_app.login_manager._update_request_context_with_user(user)
-            identity_changed.send(current_app._get_current_object(), identity=Identity(user.id))
-        return user
-
-    def logout(self):
-        with self.session_transaction() as session:
-            del session["user_id"]
-            del session["_fresh"]
-            del session["_id"]
 
 
 @pytest.fixture
-def client(app):
-    """
-    Fixes https://github.com/pytest-dev/pytest-flask/issues/42
-    """
-    return app.test_client()
-
-
-class ApiClient(object):
-    def __init__(self, client):
-        self.client = client
-        self._user = None
-
-    def login(self, *args, **kwargs):
-        return self.client.login(*args, **kwargs)
-
-    @contextmanager
-    def user(self, user=None):
-        self._user = user or UserFactory()
-        if not self._user.apikey:
-            self._user.generate_api_key()
-            self._user.save()
-        yield self._user
-
-    def perform(self, verb, url, **kwargs):
-        headers = kwargs.pop("headers", {})
-        headers["Content-Type"] = "application/json"
-
-        data = kwargs.get("data")
-        if data is not None:
-            data = json.dumps(data)
-            headers["Content-Length"] = len(data)
-            kwargs["data"] = data
-
-        if self._user:
-            headers["X-API-KEY"] = kwargs.get("X-API-KEY", self._user.apikey)
-
-        kwargs["headers"] = headers
-        method = getattr(self.client, verb)
-        return method(url, **kwargs)
-
-    def get(self, url, *args, **kwargs):
-        return self.perform("get", url, *args, **kwargs)
-
-    def post(self, url, data=None, json=True, *args, **kwargs):
-        if not json:
-            return self.client.post(url, data or {}, *args, **kwargs)
-        return self.perform("post", url, data=data or {}, *args, **kwargs)
-
-    def put(self, url, data=None, json=True, *args, **kwargs):
-        if not json:
-            return self.client.put(url, data or {}, *args, **kwargs)
-        return self.perform("put", url, data=data or {}, *args, **kwargs)
-
-    def patch(self, url, data=None, json=True, *args, **kwargs):
-        if not json:
-            return self.client.patch(url, data or {}, *args, **kwargs)
-        return self.perform("patch", url, data=data or {}, *args, **kwargs)
-
-    def delete(self, url, data=None, *args, **kwargs):
-        return self.perform("delete", url, data=data or {}, *args, **kwargs)
-
-    def options(self, url, data=None, *args, **kwargs):
-        return self.perform("options", url, data=data or {}, *args, **kwargs)
-
-
-@pytest.fixture
-def api(client):
-    api_client = ApiClient(client)
-    return api_client
-
-
-@pytest.fixture(name="cli")
-def cli_fixture(app):
-    def mock_runner(*args, **kwargs):
-        from udata.commands import cli
-
-        if len(args) == 1 and " " in args[0]:
-            args = shlex.split(args[0])
-        runner = app.test_cli_runner()
-        result = runner.invoke(cli, args, catch_exceptions=False)
-        if kwargs.get("check", True):
-            assert_command_ok(result)
-        return result
+def rmock():
+    """A requests-mock fixture"""
+    import requests_mock
 
-    return mock_runner
+    with requests_mock.Mocker() as m:
+        m.ANY = requests_mock.ANY
+        yield m
 
 
 @pytest.fixture
 def instance_path(app, tmpdir):
     """Use temporary application instance_path"""
     from udata.core import storages
-    from udata.core.storages.views import blueprint
 
     app.instance_path = str(tmpdir)
     app.config["FS_ROOT"] = str(tmpdir / "fs")
@@ -152,133 +25,5 @@ def instance_path(app, tmpdir):
         app.config.pop(key.format("ROOT"), None)
 
     storages.init_app(app)
-    app.register_blueprint(blueprint, name="test-storage")
 
     return tmpdir
-
-
-class ContextVariableDoesNotExist(Exception):
-    pass
-
-
-class TemplateRecorder:
-    @contextmanager
-    def capture(self):
-        self.templates = []
-        template_rendered.connect(self._add_template)
-        yield
-        template_rendered.disconnect(self._add_template)
-
-    def _add_template(self, app, template, context):
-        self.templates.append((template, context))
-
-    def assert_used(self, name):
-        """
-        Checks if a given template is used in the request.
-
-        :param name: template name
-        """
-        __tracebackhide__ = True
-
-        used_templates = []
-
-        for template, context in self.templates:
-            if template.name == name:
-                return True
-
-            used_templates.append(template)
-
-        msg = "Template %s not used. Templates were used: %s" % (
-            name,
-            " ".join(repr(used_templates)),
-        )
-        raise AssertionError(msg)
-
-    def get_context_variable(self, name):
-        """
-        Returns a variable from the context passed to the template.
-
-        :param name: name of variable
-        :raises ContextVariableDoesNotExist: if does not exist.
-        """
-        for template, context in self.templates:
-            if name in context:
-                return context[name]
-        raise ContextVariableDoesNotExist()
-
-
-@pytest.fixture
-def templates():
-    recorder = TemplateRecorder()
-    with recorder.capture():
-        yield recorder
-
-
-@pytest.fixture
-def httpretty():
-    import httpretty
-
-    httpretty.reset()
-    httpretty.enable()
-    yield httpretty
-    httpretty.disable()
-
-
-@pytest.fixture
-def rmock():
-    """A requests-mock fixture"""
-    import requests_mock
-
-    with requests_mock.Mocker() as m:
-        m.ANY = requests_mock.ANY
-        yield m
-
-
-class SitemapClient:
-    # Needed for lxml XPath not supporting default namespace
-    NAMESPACES = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
-    MISMATCH = 'URL "{0}" {1} mismatch: expected "{2}" found "{3}"'
-
-    def __init__(self, client):
-        self.client = client
-        self._sitemap = None
-
-    def fetch(self, secure=False):
-        base_url = "{0}://local.test".format("https" if secure else "http")
-        response = self.client.get("sitemap.xml", base_url=base_url)
-        assert200(response)
-        self._sitemap = etree.fromstring(response.data)
-        return self._sitemap
-
-    def xpath(self, query):
-        return self._sitemap.xpath(query, namespaces=self.NAMESPACES)
-
-    def get_by_url(self, endpoint, **kwargs):
-        url = url_for(endpoint, _external=True, **kwargs)
-        query = 's:url[s:loc="{url}"]'.format(url=url)
-        result = self.xpath(query)
-        return result[0] if result else None
-
-    def assert_url(self, url, priority, changefreq):
-        """
-        Check than a URL is present in the sitemap
-        with given `priority` and `changefreq`
-        """
-        __tracebackhide__ = True
-        r = url.xpath("s:priority", namespaces=self.NAMESPACES)
-        assert len(r) == 1, 'URL "{0}" should have one priority'.format(url)
-        found = r[0].text
-        msg = self.MISMATCH.format(url, "priority", priority, found)
-        assert found == str(priority), msg
-
-        r = url.xpath("s:changefreq", namespaces=self.NAMESPACES)
-        assert len(r) == 1, 'URL "{0}" should have one changefreq'.format(url)
-        found = r[0].text
-        msg = self.MISMATCH.format(url, "changefreq", changefreq, found)
-        assert found == changefreq, msg
-
-
-@pytest.fixture
-def sitemap(client):
-    sitemap_client = SitemapClient(client)
-    return sitemap_client

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

@@ -27,7 +27,7 @@ class CorsTest(APITestCase):
         assert "Access-Control-Allow-Origin" in response.headers
 
         # Resource permalink
-        response = self.get(f"/fr/datasets/r/{dataset.resources[0].id}", headers=cors_headers)
+        response = self.get(f"/datasets/r/{dataset.resources[0].id}", headers=cors_headers)
         assert_status(response, 404)  # The route is defined in udata-front
         assert "Access-Control-Allow-Origin" in response.headers
 

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(