udata 12.0.2.dev10__py3-none-any.whl → 13.0.1.dev21__py3-none-any.whl

udata/tests/api/test_reuses_api.py

@@ -7,13 +7,14 @@ from werkzeug.test import TestResponse
 
 import udata.core.organization.constants as org_constants
 from udata.core.badges.factories import badge_factory
+from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.organization.factories import OrganizationFactory
 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.api import APITestCase, PytestOnlyAPITestCase
 from udata.tests.helpers import (
     assert200,
     assert201,
@@ -24,19 +25,13 @@ from udata.tests.helpers import (
 )
 from udata.utils import faker
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-]
-
 
 def reuse_in_response(response: TestResponse, reuse: Reuse) -> bool:
     only_reuse = [r for r in response.json["data"] if r["id"] == str(reuse.id)]
     return len(only_reuse) > 0
 
 
-class ReuseAPITest:
-    modules = []
-
+class ReuseAPITest(PytestOnlyAPITestCase):
     def test_reuse_api_list(self, api):
         """It should fetch a reuse list from the API"""
         reuses = ReuseFactory.create_batch(3, visible=True)
@@ -381,6 +376,22 @@ class ReuseAPITest:
         response = api.delete(url_for("api.reuse", reuse=reuse))
         assert410(response)
 
+    def test_reuse_api_filter_by_dataset(self, api):
+        user = api.login()
+        dataset = DatasetFactory()
+        other_dataset = DatasetFactory()
+        ReuseFactory(owner=user, datasets=[dataset])
+
+        response = api.get(url_for("api.reuses", dataset=dataset.id))
+        assert200(response)
+        assert response.json["total"] == 1
+        assert len(response.json["data"][0]["datasets"]) == 1
+        assert response.json["data"][0]["datasets"][0]["title"] == dataset.title
+
+        response = api.get(url_for("api.reuses", dataset=other_dataset.id))
+        assert200(response)
+        assert response.json["total"] == 0
+
     def test_reuse_api_add_dataset(self, api):
         """It should add a dataset to a reuse from the API"""
         user = api.login()
@@ -431,6 +442,72 @@ class ReuseAPITest:
         reuse.reload()
         assert len(reuse.datasets) == 0
 
+    def test_reuse_api_filter_by_dataservice(self, api):
+        user = api.login()
+        dataservice = DataserviceFactory()
+        other_dataservice = DataserviceFactory()
+        ReuseFactory(owner=user, dataservices=[dataservice])
+
+        response = api.get(url_for("api.reuses", dataservice=dataservice.id))
+        assert200(response)
+        assert response.json["total"] == 1
+        assert len(response.json["data"][0]["dataservices"]) == 1
+        assert response.json["data"][0]["dataservices"][0]["title"] == dataservice.title
+
+        response = api.get(url_for("api.reuses", dataservice=other_dataservice.id))
+        assert200(response)
+        assert response.json["total"] == 0
+
+    def test_reuse_api_add_dataservice(self, api):
+        """It should add a dataset to a reuse from the API"""
+        user = api.login()
+        reuse = ReuseFactory(owner=user)
+
+        dataservice = DataserviceFactory()
+        data = {"id": dataservice.id, "class": "Dataservice"}
+        url = url_for("api.reuse_add_dataservice", reuse=reuse)
+        response = api.post(url, data)
+        assert201(response)
+        reuse.reload()
+        assert len(reuse.dataservices) == 1
+        assert reuse.dataservices[-1] == dataservice
+
+        dataservice = DataserviceFactory()
+        data = {"id": dataservice.id, "class": "dataservice"}
+        url = url_for("api.reuse_add_dataservice", reuse=reuse)
+        response = api.post(url, data)
+        assert201(response)
+        reuse.reload()
+        assert len(reuse.dataservices) == 2
+        assert reuse.dataservices[-1] == dataservice
+
+    def test_reuse_api_add_dataservice_twice(self, api):
+        """It should not add twice a dataservice to a reuse from the API"""
+        user = api.login()
+        dataservice = DataserviceFactory()
+        reuse = ReuseFactory(owner=user, dataservices=[dataservice])
+
+        data = {"id": dataservice.id, "class": "Dataservice"}
+        url = url_for("api.reuse_add_dataservice", reuse=reuse)
+        response = api.post(url, data)
+        assert200(response)
+        reuse.reload()
+        assert len(reuse.dataservices) == 1
+        assert reuse.dataservices[-1] == dataservice
+
+    def test_reuse_api_add_dataservice_not_found(self, api):
+        """It should return 404 when adding an unknown dataservice to a reuse"""
+        user = api.login()
+        reuse = ReuseFactory(owner=user)
+
+        data = {"id": "not-found", "class": "Dataservice"}
+        url = url_for("api.reuse_add_dataservice", reuse=reuse)
+        response = api.post(url, data)
+
+        assert404(response)
+        reuse.reload()
+        assert len(reuse.dataservices) == 0
+
     def test_reuse_api_feature(self, api):
         """It should mark the reuse featured on POST"""
         reuse = ReuseFactory(featured=False)
@@ -523,7 +600,7 @@ class ReuseAPITest:
             title="arealtestprefix-4", visible=True, metrics={"followers": 10}
         )
 
-        response = api.get(url_for("api.suggest_reuses"), qs={"q": "arealtestpref", "size": "5"})
+        response = api.get(url_for("api.suggest_reuses", q="arealtestpref", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -542,7 +619,7 @@ class ReuseAPITest:
         for i in range(4):
             ReuseFactory(title="testé-{0}".format(i) if i % 2 else faker.word(), visible=True)
 
-        response = api.get(url_for("api.suggest_reuses"), qs={"q": "testé", "size": "5"})
+        response = api.get(url_for("api.suggest_reuses", q="testé", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -559,20 +636,22 @@ class ReuseAPITest:
         """It should not provide reuse suggestion if no match"""
         ReuseFactory.create_batch(3, visible=True)
 
-        response = api.get(url_for("api.suggest_reuses"), qs={"q": "xxxxxx", "size": "5"})
+        response = api.get(url_for("api.suggest_reuses", q="xxxxxx", size=5))
         assert200(response)
         assert len(response.json) == 0
 
     def test_suggest_reuses_api_empty(self, api):
         """It should not provide reuse suggestion if no data"""
         # self.init_search()
-        response = api.get(url_for("api.suggest_reuses"), qs={"q": "xxxxxx", "size": "5"})
+        response = api.get(url_for("api.suggest_reuses", q="xxxxxx", size=5))
         assert200(response)
         assert len(response.json) == 0
 
 
 class ReusesFeedAPItest(APITestCase):
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=10)
     def test_recent_feed(self):
+        # We have a 10 hours delay for a new object to appear in feed. A newly created one shouldn't appear.
         ReuseFactory(title="A", datasets=[DatasetFactory()], created_at=datetime.utcnow())
         ReuseFactory(
             title="B", datasets=[DatasetFactory()], created_at=datetime.utcnow() - timedelta(days=2)
@@ -586,11 +665,11 @@ class ReusesFeedAPItest(APITestCase):
 
         feed = feedparser.parse(response.data)
 
-        self.assertEqual(len(feed.entries), 3)
-        self.assertEqual(feed.entries[0].title, "A")
-        self.assertEqual(feed.entries[1].title, "C")
-        self.assertEqual(feed.entries[2].title, "B")
+        self.assertEqual(len(feed.entries), 2)
+        self.assertEqual(feed.entries[0].title, "C")
+        self.assertEqual(feed.entries[1].title, "B")
 
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
     def test_recent_feed_owner(self):
         owner = UserFactory()
         ReuseFactory(owner=owner, datasets=[DatasetFactory()])
@@ -608,6 +687,7 @@ class ReusesFeedAPItest(APITestCase):
         self.assertEqual(author.name, owner.fullname)
         self.assertEqual(author.href, owner.url_for())
 
+    @pytest.mark.options(DELAY_BEFORE_APPEARING_IN_RSS_FEED=0)
     def test_recent_feed_org(self):
         owner = UserFactory()
         org = OrganizationFactory()
@@ -627,11 +707,9 @@ class ReusesFeedAPItest(APITestCase):
         self.assertEqual(author.href, org.url_for())
 
 
-class ReuseBadgeAPITest:
-    modules = []
-
+class ReuseBadgeAPITest(PytestOnlyAPITestCase):
     @pytest.fixture(autouse=True)
-    def setup(self, api, clean_db):
+    def setup_func(self, api):
         # Register at least two badges
         Reuse.__badges__["test-1"] = "Test 1"
         Reuse.__badges__["test-2"] = "Test 2"
@@ -692,9 +770,7 @@ class ReuseBadgeAPITest:
         assert404(response)
 
 
-class ReuseReferencesAPITest:
-    modules = []
-
+class ReuseReferencesAPITest(PytestOnlyAPITestCase):
     def test_reuse_types_list(self, api):
         """It should fetch the reuse types list from the API"""
         response = api.get(url_for("api.reuse_types"))

udata/tests/api/test_security_api.py

@@ -0,0 +1,124 @@
+from datetime import datetime
+
+import pytest
+from flask import url_for
+from flask_security.recoverable import generate_reset_password_token
+
+from udata.commands.fixtures import UserFactory
+from udata.i18n import lazy_gettext as _
+from udata.tests.api import PytestOnlyAPITestCase
+from udata.tests.helpers import capture_mails
+
+
+class SecurityAPITest(PytestOnlyAPITestCase):
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
+    def test_register(self, api):
+        # We cannot test for mail sending since they are sent with Flask
+        # directly and not with our system but if the sending is working
+        # we test the rendering of the mail.
+
+        response = api.post(
+            url_for("security.register"),
+            {
+                "first_name": "Jane",
+                "last_name": "Doe",
+                "accept_conditions": True,
+                "email": "jane@example.org",
+                "password": "Password123",
+                "password_confirm": "Password123",
+                "submit": True,
+            },
+        )
+        self.assertStatus(response, 200)
+
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None, SECURITY_RETURN_GENERIC_RESPONSES=True)
+    def test_register_existing(self, api):
+        # We cannot test for mail sending since they are sent with Flask
+        # directly and not with our system but if the sending is working
+        # we test the rendering of the mail.
+
+        UserFactory(email="jane@example.org", confirmed_at=datetime.now())
+        response = api.post(
+            url_for("security.register"),
+            {
+                "first_name": "Jane",
+                "last_name": "Doe",
+                "accept_conditions": True,
+                "email": "jane@example.org",
+                "password": "Password123",
+                "password_confirm": "Password123",
+                "submit": True,
+            },
+        )
+        self.assertStatus(response, 200)
+
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
+    def test_ask_for_reset(self, api):
+        # We cannot test for mail sending since they are sent with Flask
+        # directly and not with our system but if the sending is working
+        # we test the rendering of the mail.
+
+        UserFactory(email="jane@example.org", confirmed_at=datetime.now())
+
+        response = api.post(
+            url_for("security.forgot_password"), {"email": "jane@example.org", "submit": True}
+        )
+        self.assertStatus(response, 200)
+
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
+    def test_change_notice_mail(self, api):
+        # We cannot test for mail sending since they are sent with Flask
+        # directly and not with our system but if the sending is working
+        # we test the rendering of the mail.
+
+        user = UserFactory(
+            email="jane@example.org", password="password", confirmed_at=datetime.now()
+        )
+        self.login(user)
+
+        response = api.post(
+            url_for("security.change_password"),
+            {
+                "password": "password",
+                "new_password": "New_password123",
+                "new_password_confirm": "New_password123",
+                "submit": True,
+            },
+        )
+        self.assertStatus(response, 200)
+
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None)
+    def test_change_email_confirmation(self, api):
+        user = UserFactory(email="jane@example.org", confirmed_at=datetime.now())
+        self.login(user)
+
+        with capture_mails() as mails:
+            response = api.post(
+                url_for("security.change_email"),
+                {
+                    "new_email": "jane2@example.org",
+                    "new_email_confirm": "jane2@example.org",
+                    "submit": True,
+                },
+            )
+            self.assertStatus(response, 200)
+
+        assert len(mails) == 1
+        assert len(mails[0].recipients) == 1
+        assert mails[0].recipients[0] == "jane2@example.org"
+        assert mails[0].subject == _("Confirm your email address")
+
+    @pytest.mark.options(CAPTCHETAT_BASE_URL=None, SECURITY_RETURN_GENERIC_RESPONSES=True)
+    def test_reset_password(self, api):
+        user = UserFactory(email="jane@example.org", confirmed_at=datetime.now())
+        token = generate_reset_password_token(user)
+
+        response = api.post(
+            url_for("security.reset_password", token=token),
+            {
+                "password": "Password123",
+                "password_confirm": "Password123",
+                "submit": True,
+            },
+        )
+        self.assertStatus(response, 200)

udata/tests/api/test_swagger.py

@@ -3,12 +3,11 @@ import json
 from flask import url_for
 from flask_restx import schemas
 
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import assert200
 
 
-class SwaggerBlueprintTest:
-    modules = []
-
+class SwaggerBlueprintTest(PytestOnlyAPITestCase):
     def test_swagger_resource_type(self, api):
         response = api.get(url_for("api.specs"))
         assert200(response)

udata/tests/api/test_tags_api.py

@@ -1,15 +1,14 @@
-import pytest
 from flask import url_for
 
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.reuse.factories import ReuseFactory
 from udata.core.tags.tasks import count_tags
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import assert200
 from udata.utils import faker
 
 
-@pytest.mark.frontend
-class TagsAPITest:
+class TagsAPITest(PytestOnlyAPITestCase):
     def test_suggest_tags_api(self, api):
         """It should suggest tags"""
         for i in range(3):
@@ -19,7 +18,7 @@ class TagsAPITest:
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags"), qs={"q": "tes", "size": "5"})
+        response = api.get(url_for("api.suggest_tags", q="tes", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -39,7 +38,7 @@ class TagsAPITest:
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags"), qs={"q": "testé", "size": "5"})
+        response = api.get(url_for("api.suggest_tags", q="testé", size=5))
         assert200(response)
 
         assert len(response.json) <= 5
@@ -59,12 +58,12 @@ class TagsAPITest:
 
         count_tags()
 
-        response = api.get(url_for("api.suggest_tags"), qs={"q": "bbbb", "size": "5"})
+        response = api.get(url_for("api.suggest_tags", q="bbbb", size=5))
         assert200(response)
         assert len(response.json) == 0
 
     def test_suggest_tags_api_empty(self, api):
         """It should not provide tag suggestion if no data"""
-        response = api.get(url_for("api.suggest_tags"), qs={"q": "bbbb", "size": "5"})
+        response = api.get(url_for("api.suggest_tags", q="bbbb", size=5))
         assert200(response)
         assert len(response.json) == 0

udata/tests/api/test_transfer_api.py

@@ -12,8 +12,6 @@ from . import APITestCase
 
 
 class TransferAPITest(APITestCase):
-    modules = []
-
     def test_request_dataset_transfer(self):
         user = self.login()
         recipient_user = UserFactory()

udata/tests/api/test_user_api.py

@@ -11,8 +11,6 @@ from . import APITestCase
 
 
 class UserAPITest(APITestCase):
-    modules = []
-
     def test_follow_user(self):
         """It should follow an user on POST"""
         user = self.login()
@@ -65,7 +63,7 @@ class UserAPITest(APITestCase):
         for i in range(4):
             UserFactory(first_name="first-name-test-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "first-name-test", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="first-name-test", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -84,7 +82,7 @@ class UserAPITest(APITestCase):
         for i in range(4):
             UserFactory(last_name="last-name-test-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "last-name-test", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="last-name-test", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -102,7 +100,7 @@ class UserAPITest(APITestCase):
         for i in range(4):
             UserFactory(last_name="last-name-testé-{0}".format(i) if i % 2 else faker.word())
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "last-name-testé", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="last-name-testé", size=5))
         self.assert200(response)
 
         self.assertLessEqual(len(response.json), 5)
@@ -119,13 +117,13 @@ class UserAPITest(APITestCase):
         """It should not provide user suggestion if no match"""
         UserFactory.create_batch(3)
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "xxxxxx", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="xxxxxx", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
     def test_suggest_users_api_empty(self):
         """It should not provide user suggestion if no data"""
-        response = self.get(url_for("api.suggest_users"), qs={"q": "xxxxxx", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="xxxxxx", size=5))
         self.assert200(response)
         self.assertEqual(len(response.json), 0)
 
@@ -133,7 +131,7 @@ class UserAPITest(APITestCase):
         """It should suggest users without deduplicating homonyms"""
         UserFactory.create_batch(2, first_name="test", last_name="homonym")
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "homonym", "size": "5"})
+        response = self.get(url_for("api.suggest_users", q="homonym", size=5))
         self.assert200(response)
 
         self.assertEqual(len(response.json), 2)
@@ -144,11 +142,11 @@ class UserAPITest(APITestCase):
 
     def test_suggest_users_api_size_validation(self):
         """It should validate that the size parameter is between 1 and 20."""
-        response = self.get(url_for("api.suggest_users"), qs={"q": "foobar", "size": "0"})
+        response = self.get(url_for("api.suggest_users", q="foobar", size=0))
         self.assert400(response)
         self.assertIn("between 1 and 20", response.json["errors"]["size"])
 
-        response = self.get(url_for("api.suggest_users"), qs={"q": "foobar", "size": "21"})
+        response = self.get(url_for("api.suggest_users", q="foobar", size=21))
 
         self.assert400(response)
         self.assertIn("between 1 and 20", response.json["errors"]["size"])

udata/tests/apiv2/test_datasets.py

@@ -367,8 +367,6 @@ class DatasetResourceAPIV2Test(APITestCase):
 
 
 class DatasetExtrasAPITest(APITestCase):
-    modules = None
-
     def setUp(self):
         self.login()
         self.dataset = DatasetFactory(owner=self.user)
@@ -503,8 +501,6 @@ class DatasetExtrasAPITest(APITestCase):
 
 
 class DatasetResourceExtrasAPITest(APITestCase):
-    modules = None
-
     def setUp(self):
         self.login()
         self.dataset = DatasetFactory(owner=self.user)

udata/tests/apiv2/test_me_api.py

@@ -7,8 +7,6 @@ from udata.tests.api import APITestCase
 
 
 class MeAPIv2Test(APITestCase):
-    modules = []
-
     def test_my_org_topics(self):
         user = self.login()
         member = Member(user=user, role="editor")

udata/tests/apiv2/test_organizations.py

@@ -5,8 +5,6 @@ from udata.tests.api import APITestCase
 
 
 class OrganizationExtrasAPITest(APITestCase):
-    modules = None
-
     def setUp(self):
         self.login()
         member = Member(user=self.user, role="admin")

udata/tests/apiv2/test_swagger.py

@@ -3,12 +3,11 @@ import json
 from flask import url_for
 from flask_restx import schemas
 
+from udata.tests.api import PytestOnlyAPITestCase
 from udata.tests.helpers import assert200
 
 
-class SwaggerBlueprintTest:
-    modules = []
-
+class SwaggerBlueprintTest(PytestOnlyAPITestCase):
     def test_swagger_resource_type(self, api):
         response = api.get(url_for("apiv2.specs"))
         assert200(response)

udata/tests/apiv2/test_topics.py

@@ -27,8 +27,6 @@ from udata.tests.features.territories import create_geozones_fixtures
 
 
 class TopicsListAPITest(APITestCase):
-    modules = []
-
     def test_topic_api_list(self):
         """It should fetch a topic list from the API"""
         owner = UserFactory()

udata/tests/cli/test_cli_base.py

@@ -1,16 +1,18 @@
-def test_cli_help(cli):
-    """Should display help without errors"""
-    cli()
-    cli("-?")
-    cli("-h")
-    cli("--help")
+from udata.tests import PytestOnlyTestCase
 
 
-def test_cli_log_and_printing(cli):
-    """Should properly log and print"""
-    cli("test log")
+class CliBaseTest(PytestOnlyTestCase):
+    def test_cli_help(self, cli):
+        """Should display help without errors"""
+        cli()
+        cli("-?")
+        cli("-h")
+        cli("--help")
 
+    def test_cli_log_and_printing(self, cli):
+        """Should properly log and print"""
+        cli("test log")
 
-def test_cli_version(cli):
-    """Should display version without errors"""
-    cli("--version")
+    def test_cli_version(self, cli):
+        """Should display version without errors"""
+        cli("--version")