udata 10.4.1.dev35201__py2.py3-none-any.whl → 10.4.2__py2.py3-none-any.whl

udata/tests/api/test_dataservices_api.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 from xml.etree.ElementTree import XML
 
+import feedparser
 import pytest
 from flask import url_for
 from werkzeug.test import TestResponse
@@ -627,3 +628,55 @@ class DataserviceRdfViewsTest:
         response = client.get(url, headers={"Accept": mime})
         assert200(response)
         assert response.content_type == mime
+
+
+class DataservicesFeedAPItest(APITestCase):
+    def test_recent_feed(self):
+        dataservices = [DataserviceFactory() for i in range(3)]
+
+        response = self.get(url_for("api.recent_dataservices_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), len(dataservices))
+        for i in range(1, len(feed.entries)):
+            published_date = feed.entries[i].published_parsed
+            prev_published_date = feed.entries[i - 1].published_parsed
+            self.assertGreaterEqual(prev_published_date, published_date)
+
+    def test_recent_feed_owner(self):
+        owner = UserFactory()
+        DataserviceFactory(owner=owner)
+
+        response = self.get(url_for("api.recent_dataservices_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, owner.fullname)
+        self.assertEqual(author.href, owner.external_url)
+
+    def test_recent_feed_org(self):
+        owner = UserFactory()
+        org = OrganizationFactory()
+        DataserviceFactory(owner=owner, organization=org)
+
+        response = self.get(url_for("api.recent_dataservices_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, org.name)
+        self.assertEqual(author.href, org.external_url)

udata/tests/api/test_datasets_api.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from io import BytesIO
 from uuid import uuid4
 
+import feedparser
 import pytest
 import pytz
 import requests_mock
@@ -977,6 +978,14 @@ class DatasetAPITest(APITestCase):
         dataset = Dataset.objects.first()
         self.assertEqual(dataset.contact_points[0].name, contact_point_data["name"])
 
+        data["contact_points"] = []
+        response = self.put(url_for("api.dataset", dataset=dataset), data)
+        self.assert200(response)
+
+        dataset = Dataset.objects.first()
+        # This is weird, we should have no contact point if sending an empty array… :RemoveAllContactPoints (in cdata)
+        self.assertEqual(dataset.contact_points[0].name, contact_point_data["name"])
+
         data["contact_points"] = None
         response = self.put(url_for("api.dataset", dataset=dataset), data)
         self.assert200(response)
@@ -1242,6 +1251,58 @@ class DatasetAPITest(APITestCase):
         }
 
 
+class DatasetsFeedAPItest(APITestCase):
+    def test_recent_feed(self):
+        datasets = [DatasetFactory(resources=[ResourceFactory()]) for i in range(3)]
+
+        response = self.get(url_for("api.recent_datasets_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), len(datasets))
+        for i in range(1, len(feed.entries)):
+            published_date = feed.entries[i].published_parsed
+            prev_published_date = feed.entries[i - 1].published_parsed
+            self.assertGreaterEqual(prev_published_date, published_date)
+
+    def test_recent_feed_owner(self):
+        owner = UserFactory()
+        DatasetFactory(owner=owner, resources=[ResourceFactory()])
+
+        response = self.get(url_for("api.recent_datasets_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, owner.fullname)
+        self.assertEqual(author.href, owner.external_url)
+
+    def test_recent_feed_org(self):
+        owner = UserFactory()
+        org = OrganizationFactory()
+        DatasetFactory(owner=owner, organization=org, resources=[ResourceFactory()])
+
+        response = self.get(url_for("api.recent_datasets_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, org.name)
+        self.assertEqual(author.href, org.external_url)
+
+
 class DatasetBadgeAPITest(APITestCase):
     @classmethod
     def setUpClass(cls):

udata/tests/api/test_organizations_api.py

@@ -8,6 +8,7 @@ import udata.core.organization.constants as org_constants
 from udata.core import csv
 from udata.core.badges.factories import badge_factory
 from udata.core.badges.signals import on_badge_added, on_badge_removed
+from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.discussions.factories import DiscussionFactory
 from udata.core.organization.factories import OrganizationFactory
@@ -362,10 +363,10 @@ class MembershipAPITest:
         assert len(members) == 2
         assert members[0]["role"] == "admin"
         assert members[0]["since"] == "2024-04-14T00:00:00+00:00"
-        assert members[0]["user"]["email"] is None
+        assert members[0]["user"]["email"] == "***@example.org"
 
         assert members[1]["role"] == "editor"
-        assert members[1]["user"]["email"] is None
+        assert members[1]["user"]["email"] == "***@example.org"
 
         # Super admin of udata can see emails
         api.login(AdminFactory())
@@ -1042,6 +1043,30 @@ class OrganizationCsvExportsTest:
         assert str(hidden_dataset.id) not in dataset_ids
         assert str(not_org_dataset.id) not in dataset_ids
 
+    def test_dataservices_csv(self, api):
+        org = OrganizationFactory()
+        [DataserviceFactory(organization=org) for _ in range(3)]
+
+        response = api.get(url_for("api.organization_dataservices_csv", org=org))
+
+        assert200(response)
+        assert response.mimetype == "text/csv"
+        assert response.charset == "utf-8"
+
+        csvfile = StringIO(response.data.decode("utf-8"))
+        reader = csv.get_reader(csvfile)
+        header = next(reader)
+
+        assert header[0] == "id"
+        assert "title" in header
+        assert "url" in header
+        assert "description" in header
+        assert "created_at" in header
+        assert "metadata_modified_at" in header
+        assert "tags" in header
+        assert "metric.views" in header
+        assert "datasets" in header
+
     def test_discussions_csv_content_empty(self, api):
         organization = OrganizationFactory()
         response = api.get(url_for("api.organization_discussions_csv", org=organization))

udata/tests/api/test_reuses_api.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 
+import feedparser
 import pytest
 from flask import url_for
 from werkzeug.test import TestResponse
@@ -12,6 +13,7 @@ from udata.core.reuse.constants import REUSE_TOPICS, REUSE_TYPES
 from udata.core.reuse.factories import ReuseFactory
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.models import Follow, Member, Reuse
+from udata.tests.api import APITestCase
 from udata.tests.helpers import (
     assert200,
     assert201,
@@ -569,6 +571,58 @@ class ReuseAPITest:
         assert len(response.json) == 0
 
 
+class ReusesFeedAPItest(APITestCase):
+    def test_recent_feed(self):
+        datasets = [ReuseFactory(datasets=[DatasetFactory()]) for i in range(3)]
+
+        response = self.get(url_for("api.recent_reuses_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), len(datasets))
+        for i in range(1, len(feed.entries)):
+            published_date = feed.entries[i].published_parsed
+            prev_published_date = feed.entries[i - 1].published_parsed
+            self.assertGreaterEqual(prev_published_date, published_date)
+
+    def test_recent_feed_owner(self):
+        owner = UserFactory()
+        ReuseFactory(owner=owner, datasets=[DatasetFactory()])
+
+        response = self.get(url_for("api.recent_reuses_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, owner.fullname)
+        self.assertEqual(author.href, owner.external_url)
+
+    def test_recent_feed_org(self):
+        owner = UserFactory()
+        org = OrganizationFactory()
+        ReuseFactory(owner=owner, organization=org, datasets=[DatasetFactory()])
+
+        response = self.get(url_for("api.recent_reuses_atom_feed"))
+
+        self.assert200(response)
+
+        feed = feedparser.parse(response.data)
+
+        self.assertEqual(len(feed.entries), 1)
+        entry = feed.entries[0]
+        self.assertEqual(len(entry.authors), 1)
+        author = entry.authors[0]
+        self.assertEqual(author.name, org.name)
+        self.assertEqual(author.href, org.external_url)
+
+
 class ReuseBadgeAPITest:
     modules = []
 

udata/tests/dataset/test_csv_adapter.py

@@ -21,7 +21,10 @@ class DatasetCSVAdapterTest:
                         "created_at": date_created,
                         "modified_at": date_modified,
                         "uri": "http://domain.gouv.fr/dataset/uri",
-                    }
+                    },
+                    metrics={
+                        "views": 42,
+                    },
                 )
             ],
             harvest={
@@ -41,6 +44,8 @@ class DatasetCSVAdapterTest:
         assert date_modified.isoformat() in d_row
         # dataset harvest dates should not be here
         assert another_date.isoformat() not in d_row
+        # assert resource metrics downloads
+        assert 42 in d_row
 
     def test_datasets_csv_adapter(self):
         date_created = datetime(2022, 12, 31)
@@ -87,10 +92,8 @@ class DatasetCSVAdapterTest:
         assert harvest_dataset_values["harvest.domain"] == "example.com"
         assert harvest_dataset_values["harvest.remote_url"] == "https://www.example.com/"
         assert harvest_dataset_values["resources_count"] == 0
-        assert harvest_dataset_values["downloads"] == 0
 
         resources_dataset_values = csv[str(resources_dataset.id)]
         assert resources_dataset_values["resources_count"] == 3
         assert resources_dataset_values["main_resources_count"] == 1
         assert set(resources_dataset_values["resources_formats"].split(",")) == set(["csv", "json"])
-        assert resources_dataset_values["downloads"] == 1337 + 42

udata/tests/dataset/test_dataset_model.py

@@ -9,6 +9,14 @@ from mongoengine import ValidationError as MongoEngineValidationError
 from mongoengine import post_save
 
 from udata.app import cache
+from udata.core.dataset.activities import (
+    UserAddedResourceToDataset,
+    UserCreatedDataset,
+    UserDeletedDataset,
+    UserRemovedResourceFromDataset,
+    UserUpdatedDataset,
+    UserUpdatedResource,
+)
 from udata.core.dataset.constants import LEGACY_FREQUENCIES, UPDATE_FREQUENCIES
 from udata.core.dataset.exceptions import (
     SchemasCacheUnavailableException,
@@ -350,6 +358,47 @@ class DatasetModelTest:
 
         assert dataset_without_resources.resources_len == 0
 
+    def test_dataset_activities(self, api, mocker):
+        # A user must be authenticated for activities to be emitted
+        user = api.login()
+
+        mock_created = mocker.patch.object(UserCreatedDataset, "emit")
+        mock_updated = mocker.patch.object(UserUpdatedDataset, "emit")
+        mock_deleted = mocker.patch.object(UserDeletedDataset, "emit")
+        mock_resource_added = mocker.patch.object(UserAddedResourceToDataset, "emit")
+        mock_resouce_updated = mocker.patch.object(UserUpdatedResource, "emit")
+        mock_resouce_removed = mocker.patch.object(UserRemovedResourceFromDataset, "emit")
+
+        with assert_emit(Dataset.on_create):
+            dataset = DatasetFactory(owner=user)
+            mock_created.assert_called()
+
+        with assert_emit(Dataset.on_update):
+            dataset.title = "new title"
+            dataset.save()
+            mock_updated.assert_called()
+
+        with assert_emit(Dataset.on_resource_added):
+            dataset.add_resource(ResourceFactory())
+            mock_resource_added.assert_called()
+
+        dataset.reload()
+
+        with assert_emit(Dataset.on_resource_updated):
+            resource = dataset.resources[0]
+            resource.description = "New description"
+            dataset.update_resource(resource)
+            mock_resouce_updated.assert_called()
+
+        with assert_emit(Dataset.on_resource_removed):
+            dataset.remove_resource(dataset.resources[-1])
+            mock_resouce_removed.assert_called()
+
+        with assert_emit(Dataset.on_delete):
+            dataset.deleted = datetime.utcnow()
+            dataset.save()
+            mock_deleted.assert_called()
+
 
 class ResourceModelTest:
     def test_url_is_required(self):

udata/tests/test_topics.py

@@ -1,8 +1,11 @@
 import pytest
 
 from udata.core.dataset.factories import DatasetFactory
+from udata.core.topic.activities import UserCreatedTopic, UserUpdatedTopic
 from udata.core.topic.factories import TopicFactory
+from udata.core.topic.models import Topic
 from udata.search import reindex
+from udata.tests.helpers import assert_emit
 
 
 @pytest.fixture
@@ -45,3 +48,19 @@ class TopicModelTest:
         # creates a topic with datasets, thus calls reindex
         TopicFactory()
         job_reindex_undelayed.assert_called()
+
+    def test_topic_activities(self, api, mocker):
+        # A user must be authenticated for activities to be emitted
+        user = api.login()
+
+        mock_created = mocker.patch.object(UserCreatedTopic, "emit")
+        mock_updated = mocker.patch.object(UserUpdatedTopic, "emit")
+
+        with assert_emit(Topic.on_create):
+            topic = TopicFactory(owner=user)
+            mock_created.assert_called()
+
+        with assert_emit(Topic.on_update):
+            topic.name = "new name"
+            topic.save()
+            mock_updated.assert_called()

{udata-10.4.1.dev35201.dist-info → udata-10.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udata
-Version: 10.4.1.dev35201
+Version: 10.4.2
 Summary: Open data portal
 Home-page: https://github.com/opendatateam/udata
 Author: Opendata Team
@@ -48,6 +48,7 @@ Requires-Dist: dnspython==2.7.0
 Requires-Dist: email-validator==2.2.0
 Requires-Dist: factory-boy==3.3.3
 Requires-Dist: faker==37.0.2
+Requires-Dist: feedgenerator==2.1.0
 Requires-Dist: filelock==3.18.0
 Requires-Dist: flask==2.1.2
 Requires-Dist: flask-babel==4.0.0
@@ -139,8 +140,22 @@ It is collectively taken care of by members of the
 
 # Changelog
 
-## Current (in progress)
+## 10.4.2 (2025-06-05)
 
+- :warning: Add migration to clean duplicate activities [#3327](https://github.com/opendatateam/udata/pull/3327)
+- Add test for removing last contact point [#3322](https://github.com/opendatateam/udata/pull/3322)
+- Add activities to dataservices, topics and resources, add Auditable class to refactor improve code [#3308](https://github.com/opendatateam/udata/pull/3308) [#3333](https://github.com/opendatateam/udata/pull/3333)
+- Store activities for private objects [#3328](https://github.com/opendatateam/udata/pull/3328)
+- Do not crash if file doesn't exists during resource deletion [#3323](https://github.com/opendatateam/udata/pull/3323)
+- Show user domain in suggest [#3324](https://github.com/opendatateam/udata/pull/3324)
+- Add new global site metrics [#3325](https://github.com/opendatateam/udata/pull/3325)
+- Keep the existing frequency if not found during harvesting [#3330](https://github.com/opendatateam/udata/pull/3330)
+- Migrate atom feeds from udata-front to udata [#3326](https://github.com/opendatateam/udata/pull/3326)
+- Add organization dataservices catalog route [#3332](https://github.com/opendatateam/udata/pull/3332)
+
+## 10.4.1 (2025-05-20)
+
+- Remove duplicate `downloads` in dataset csv adapter [#3319](https://github.com/opendatateam/udata/pull/3319)
 - Add missing default for license full object [#3317](https://github.com/opendatateam/udata/pull/3317/)
 - Check for slugs in followers API [#3320](https://github.com/opendatateam/udata/pull/3320)
 - Fix missing ID in dataset reuses mask [#3321](https://github.com/opendatateam/udata/pull/3321)