udata 10.1.2.dev34172__py2.py3-none-any.whl → 10.1.3__py2.py3-none-any.whl

udata/tests/api/test_datasets_api.py

@@ -558,6 +558,18 @@ class DatasetAPITest(APITestCase):
         self.assertEqual(Dataset.objects.count(), 1)
         self.assertEqual(Dataset.objects.first().description, "new description")
 
+    def test_cannot_modify_dataset_id(self):
+        user = self.login()
+        dataset = DatasetFactory(owner=user)
+
+        data = dataset.to_dict()
+        data["id"] = "7776aa373aa050e302b5714d"
+
+        response = self.put(url_for("api.dataset", dataset=dataset.id), data)
+
+        self.assert200(response)
+        self.assertEqual(response.json["id"], str(dataset.id))
+
     def test_dataset_api_update_org(self):
         """It shouldn't update the dataset org"""
         user = self.login()
@@ -1130,6 +1142,37 @@ class DatasetResourceAPITest(APITestCase):
         # should fail because the POST endpoint only supports URL setting for remote resources
         self.assert400(response)
 
+    def test_creating_and_updating_resource_uuid(self):
+        uuid_a = "c312cfb0-60f7-417c-9cf9-3d985196b22a"
+        uuid_b = "e8262134-5ff0-4bd8-98bc-5db76bb27856"
+
+        data = ResourceFactory.as_dict()
+        data["filetype"] = "remote"
+        data["id"] = uuid_a
+        response = self.post(url_for("api.resources", dataset=self.dataset), data)
+        self.assert201(response)
+        self.assertNotEqual(response.json["id"], uuid_a)
+
+        first_generated_uuid = response.json["id"]
+
+        # Sending the same UUID twice doesn't change anything…
+        data = ResourceFactory.as_dict()
+        data["filetype"] = "remote"
+        data["id"] = first_generated_uuid
+        response = self.post(url_for("api.resources", dataset=self.dataset), data)
+        self.assert201(response)
+        self.assertNotEqual(response.json["id"], first_generated_uuid)
+
+        # Cannot modify the ID of an existing resource
+        data = response.json
+        data["id"] = uuid_b
+        response = self.put(
+            url_for("api.resource", dataset=self.dataset, rid=first_generated_uuid),
+            data,
+        )
+        self.assert200(response)
+        self.assertEqual(response.json["id"], first_generated_uuid)
+
     def test_create_normalize_format(self):
         _format = " FORMAT "
         data = ResourceFactory.as_dict()
@@ -1295,6 +1338,21 @@ class DatasetResourceAPITest(APITestCase):
         self.assertEqual(updated.url, data["url"])
         self.assertEqual(updated.extras, {"extra:id": "id"})
 
+    def test_cannot_update_resource_filetype(self):
+        user = self.login()
+        resource = ResourceFactory(filetype="file")
+        dataset = DatasetFactory(owner=user, resources=[resource])
+
+        data = {
+            "filetype": "remote",
+            "url": faker.url(),
+        }
+        response = self.put(url_for("api.resource", dataset=dataset, rid=str(resource.id)), data)
+        self.assert400(response)
+
+        dataset.reload()
+        self.assertEqual(dataset.resources[0].filetype, "file")
+
     def test_bulk_update(self):
         resources = ResourceFactory.build_batch(2)
         self.dataset.resources.extend(resources)

udata/tests/api/test_me_api.py

@@ -332,7 +332,7 @@ class MeAPITest(APITestCase):
 
         # The discussions are kept but the messages are anonymized
         self.assertEqual(len(discussion.discussion), 2)
-        self.assertEqual(discussion.discussion[0].content, "DELETED")
+        self.assertEqual(discussion.discussion[0].posted_by.fullname, "DELETED DELETED")
         self.assertEqual(discussion.discussion[1].content, other_disc_msg_content)
 
         # The datasets are unchanged

udata/tests/api/test_transfer_api.py

@@ -2,8 +2,10 @@ from bson import ObjectId
 from flask import url_for
 
 from udata.core.dataset.factories import DatasetFactory
+from udata.core.dataset.models import Dataset
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.user.factories import UserFactory
+from udata.core.user.models import User
 from udata.utils import faker
 
 from . import APITestCase
@@ -214,3 +216,39 @@ class TransferAPITest(APITestCase):
         data = response.json
 
         self.assertIn("recipient", data["errors"])
+
+    def test_cannot_accept_or_refuse_transfer_after_accepting_or_refusing(self):
+        user = self.login()
+        new_user = UserFactory()
+        dataset = DatasetFactory(owner=user)
+
+        response = self._create_transfer(dataset, new_user)
+        self.assert201(response)
+
+        transfer = response.json
+
+        self.login(new_user)
+        response = self.post(url_for("api.transfer", id=transfer["id"]), {"response": "accept"})
+        self.assert200(response)
+
+        response = self.post(url_for("api.transfer", id=transfer["id"]), {"response": "accept"})
+        self.assert400(response)
+
+        response = self.post(url_for("api.transfer", id=transfer["id"]), {"response": "refuse"})
+        self.assert400(response)
+
+    def _create_transfer(self, source: Dataset, destination: User):
+        return self.post(
+            url_for("api.transfers"),
+            {
+                "subject": {
+                    "class": "Dataset",
+                    "id": str(source.id),
+                },
+                "recipient": {
+                    "class": "User",
+                    "id": str(destination.id),
+                },
+                "comment": "Some comment",
+            },
+        )

udata/tests/api/test_user_api.py

@@ -1,8 +1,9 @@
 from flask import url_for
 
 from udata.core import storages
+from udata.core.discussions.factories import DiscussionFactory, MessageDiscussionFactory
 from udata.core.user.factories import AdminFactory, UserFactory
-from udata.models import Follow
+from udata.models import Discussion, Follow
 from udata.tests.helpers import capture_mails, create_test_image
 from udata.utils import faker
 
@@ -352,36 +353,74 @@ class UserAPITest(APITestCase):
     def test_delete_user(self):
         user = AdminFactory()
         self.login(user)
-        other_user = UserFactory()
+        user_to_delete = UserFactory()
         file = create_test_image()
+        discussion = DiscussionFactory(
+            user=user_to_delete,
+            discussion=[
+                MessageDiscussionFactory(posted_by=user_to_delete),
+                MessageDiscussionFactory(posted_by=user_to_delete),
+            ],
+        )
 
         response = self.post(
-            url_for("api.user_avatar", user=other_user),
+            url_for("api.user_avatar", user=user_to_delete),
             {"file": (file, "test.png")},
             json=False,
         )
         with capture_mails() as mails:
-            response = self.delete(url_for("api.user", user=other_user))
+            response = self.delete(url_for("api.user", user=user_to_delete))
             self.assertEqual(list(storages.avatars.list_files()), [])
             self.assert204(response)
             self.assertEquals(len(mails), 1)
 
-        other_user.reload()
-        response = self.delete(url_for("api.user", user=other_user))
+        user_to_delete.reload()
+        response = self.delete(url_for("api.user", user=user_to_delete))
         self.assert410(response)
         response = self.delete(url_for("api.user", user=user))
         self.assert403(response)
 
+        # discussions are kept by default
+        discussion.reload()
+        assert len(discussion.discussion) == 2
+        assert discussion.discussion[1].content != "DELETED"
+
     def test_delete_user_without_notify(self):
         user = AdminFactory()
         self.login(user)
-        other_user = UserFactory()
+        user_to_delete = UserFactory()
 
         with capture_mails() as mails:
-            response = self.delete(url_for("api.user", user=other_user, no_mail=True))
+            response = self.delete(url_for("api.user", user=user_to_delete, no_mail=True))
             self.assert204(response)
             self.assertEqual(len(mails), 0)
 
+    def test_delete_user_with_comments_deletion(self):
+        user = AdminFactory()
+        self.login(user)
+        user_to_delete = UserFactory()
+        discussion_only_user = DiscussionFactory(
+            user=user_to_delete,
+            discussion=[
+                MessageDiscussionFactory(posted_by=user_to_delete),
+                MessageDiscussionFactory(posted_by=user_to_delete),
+            ],
+        )
+        discussion_with_other = DiscussionFactory(
+            user=user,
+            discussion=[
+                MessageDiscussionFactory(posted_by=user),
+                MessageDiscussionFactory(posted_by=user_to_delete),
+            ],
+        )
+
+        response = self.delete(url_for("api.user", user=user_to_delete, delete_comments=True))
+        self.assert204(response)
+
+        assert Discussion.objects(id=discussion_only_user.id).first() is None
+        discussion_with_other.reload()
+        assert discussion_with_other.discussion[1].content == "DELETED"
+
     def test_contact_points(self):
         user = AdminFactory()
         self.login(user)

udata/tests/dataservice/test_csv_adapter.py

@@ -18,6 +18,7 @@ class DataserviceCSVAdapterTest:
             metadata_modified_at=datetime(2023, 1, 1),
             organization=OrganizationFactory(),
             datasets=[DatasetFactory(), DatasetFactory()],
+            metrics={"views": 42},
         )
         [DataserviceFactory() for _ in range(10)]
         adapter = DataserviceCsvAdapter(Dataservice.objects.all())
@@ -41,3 +42,4 @@ class DataserviceCSVAdapterTest:
         assert dataservice_values["datasets"] == ",".join(
             str(dataset.id) for dataset in dataservice.datasets
         )
+        assert dataservice_values["metric.views"] == dataservice.metrics["views"]

udata/tests/dataset/test_dataset_model.py

@@ -1,8 +1,10 @@
 from datetime import datetime, timedelta
+from uuid import uuid4
 
 import pytest
 import requests
 from flask import current_app
+from mongoengine import ValidationError as MongoEngineValidationError
 from mongoengine import post_save
 
 from udata.app import cache
@@ -59,6 +61,18 @@ class DatasetModelTest:
         assert len(dataset.resources) == 2
         assert dataset.resources[0].id == resource.id
 
+    def test_add_two_resources_with_same_id(self):
+        uuid = uuid4()
+        user = UserFactory()
+        dataset = DatasetFactory(owner=user)
+        resource_a = ResourceFactory(id=uuid)
+        resource_b = ResourceFactory(id=uuid)
+
+        dataset.add_resource(resource_a)
+        dataset.add_resource(ResourceFactory())
+        with pytest.raises(MongoEngineValidationError):
+            dataset.add_resource(resource_b)
+
     def test_add_resource_missing_checksum_type(self):
         user = UserFactory()
         dataset = DatasetFactory(owner=user)

udata/tests/user/test_user_tasks.py

@@ -0,0 +1,144 @@
+from datetime import datetime, timedelta
+
+import pytest
+from flask import current_app
+
+from udata.core.discussions.factories import DiscussionFactory
+from udata.core.user import tasks
+from udata.core.user.factories import UserFactory
+from udata.core.user.models import User
+from udata.i18n import gettext as _
+from udata.tests.api import APITestCase
+from udata.tests.helpers import capture_mails
+
+
+class UserTasksTest(APITestCase):
+    @pytest.mark.options(YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION=3)
+    def test_notify_inactive_users(self):
+        notification_comparison_date = (
+            datetime.utcnow()
+            - timedelta(days=current_app.config["YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION"] * 365)
+            + timedelta(days=current_app.config["DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY"])
+            - timedelta(days=1)  # add margin
+        )
+
+        inactive_user = UserFactory(current_login_at=notification_comparison_date)
+        UserFactory(current_login_at=datetime.utcnow())  # Active user
+
+        with capture_mails() as mails:
+            tasks.notify_inactive_users()
+
+        # Assert (only one) mail has been sent
+        self.assertEqual(len(mails), 1)
+        self.assertEqual(mails[0].send_to, set([inactive_user.email]))
+        self.assertEqual(
+            mails[0].subject,
+            _("Inactivity of your {site} account").format(site=current_app.config["SITE_TITLE"]),
+        )
+
+        # We shouldn't notify users twice
+        with capture_mails() as mails:
+            tasks.notify_inactive_users()
+
+        self.assertEqual(len(mails), 0)
+
+    @pytest.mark.options(YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION=3)
+    @pytest.mark.options(MAX_NUMBER_OF_USER_INACTIVITY_NOTIFICATIONS=10)
+    def test_notify_inactive_users_max_notifications(self):
+        notification_comparison_date = (
+            datetime.utcnow()
+            - timedelta(days=current_app.config["YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION"] * 365)
+            + timedelta(days=current_app.config["DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY"])
+            - timedelta(days=1)  # add margin
+        )
+
+        NB_USERS_TO_NOTIFY = 15
+
+        [UserFactory(current_login_at=notification_comparison_date) for _ in range(15)]
+        UserFactory(current_login_at=datetime.utcnow())  # Active user
+
+        with capture_mails() as mails:
+            tasks.notify_inactive_users()
+
+        # Assert MAX_NUMBER_OF_USER_INACTIVITY_NOTIFICATIONS mails have been sent
+        self.assertEqual(
+            len(mails), current_app.config["MAX_NUMBER_OF_USER_INACTIVITY_NOTIFICATIONS"]
+        )
+
+        # Second batch
+        with capture_mails() as mails:
+            tasks.notify_inactive_users()
+
+        # Assert what's left have been sent
+        self.assertEqual(
+            len(mails),
+            NB_USERS_TO_NOTIFY - current_app.config["MAX_NUMBER_OF_USER_INACTIVITY_NOTIFICATIONS"],
+        )
+
+    @pytest.mark.options(YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION=3)
+    def test_delete_inactive_users(self):
+        deletion_comparison_date = (
+            datetime.utcnow()
+            - timedelta(days=current_app.config["YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION"] * 365)
+            - timedelta(days=1)  # add margin
+        )
+
+        notification_comparison_date = (
+            datetime.utcnow()
+            - timedelta(days=current_app.config["DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY"])
+            - timedelta(days=1)  # add margin
+        )
+
+        inactive_user_to_delete = UserFactory(
+            current_login_at=deletion_comparison_date,
+            inactive_deletion_notified_at=notification_comparison_date,
+        )
+        UserFactory(current_login_at=datetime.utcnow())  # Active user
+        discussion = DiscussionFactory(user=inactive_user_to_delete)
+        discussion_title = discussion.title
+
+        with capture_mails() as mails:
+            tasks.delete_inactive_users()
+
+        # Assert (only one) mail has been sent
+        self.assertEqual(len(mails), 1)
+        self.assertEqual(mails[0].send_to, set([inactive_user_to_delete.email]))
+        self.assertEqual(
+            mails[0].subject,
+            _(
+                _("Deletion of your inactive {site} account").format(
+                    site=current_app.config["SITE_TITLE"]
+                )
+            ),
+        )
+
+        # Assert user has been deleted but not its discussion
+        inactive_user_to_delete.reload()
+        discussion.reload()
+        self.assertEqual(inactive_user_to_delete.fullname, "DELETED DELETED")
+        self.assertEqual(discussion.title, discussion_title)
+
+    @pytest.mark.options(YEARS_OF_INACTIVITY_BEFORE_DEACTIVATION=3)
+    def test_keep_inactive_users_that_logged_in(self):
+        notification_comparison_date = (
+            datetime.utcnow()
+            - timedelta(days=current_app.config["DAYS_BEFORE_ACCOUNT_INACTIVITY_NOTIFY_DELAY"])
+            - timedelta(days=1)  # add margin
+        )
+
+        inactive_user_that_logged_in_since_notification = UserFactory(
+            current_login_at=datetime.utcnow(),
+            inactive_deletion_notified_at=notification_comparison_date,
+        )
+
+        with capture_mails() as mails:
+            tasks.delete_inactive_users()
+
+        # Assert no mail has been sent
+        self.assertEqual(len(mails), 0)
+
+        # Assert user hasn't been deleted and won't be deleted
+        self.assertEqual(User.objects().count(), 1)
+        user = User.objects().first()
+        self.assertEqual(user, inactive_user_that_logged_in_since_notification)
+        self.assertIsNone(user.inactive_deletion_notified_at)