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

udata/tests/api/test_contact_points.py

@@ -1,4 +1,3 @@
-import pytest
 from flask import url_for
 
 from udata.core.contact_point.factories import ContactPointFactory
@@ -7,17 +6,12 @@ from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Member
 from udata.i18n import gettext as _
 from udata.models import ContactPoint
+from udata.tests.api import APITestCase
 from udata.tests.helpers import assert200, assert201, assert204, assert400, assert403
 from udata.utils import faker
 
-pytestmark = [
-    pytest.mark.usefixtures("clean_db"),
-]
-
-
-class ContactPointAPITest:
-    modules = []
 
+class ContactPointAPITest(APITestCase):
     def test_get_or_create(self):
         org = OrganizationFactory()
         contact_point, created = ContactPoint.objects().get_or_create(
@@ -51,46 +45,46 @@ class ContactPointAPITest:
         assert created
         assert contact_point.name == "Another"
 
-    def test_contact_point_api_create(self, api):
-        user = api.login()
+    def test_contact_point_api_create(self):
+        user = self.login()
         data = {
             "name": faker.word(),
             "email": faker.email(),
             "contact_form": faker.url(),
             "role": "contact",
         }
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
         contact_point = ContactPoint.objects.first()
         assert contact_point.owner.id == user.id
 
-    def test_contact_point_api_create_email_or_contact_form(self, api):
-        api.login()
+    def test_contact_point_api_create_email_or_contact_form(self):
+        self.login()
         data = {"name": faker.word(), "contact_form": faker.url(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
         data = {"name": faker.word(), "email": faker.email(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 2
 
-    def test_contact_point_duplicate_creation(self, api):
-        api.login()
+    def test_contact_point_duplicate_creation(self):
+        self.login()
         data = {"name": faker.word(), "contact_form": faker.url(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
 
-    def test_contact_point_for_different_org(self, api):
-        user = api.login()
+    def test_contact_point_for_different_org(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org_a = OrganizationFactory(members=[member])
 
@@ -100,11 +94,11 @@ class ContactPointAPITest:
             "role": "contact",
             "organization": str(org_a.id),
         }
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 1
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
 
@@ -114,39 +108,39 @@ class ContactPointAPITest:
 
         org_b = OrganizationFactory(members=[])
         data["organization"] = str(org_b.id)
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert ContactPoint.objects.count() == 1
 
         org_b.members = [Member(user=user, role="editor")]
         org_b.save()
 
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert201(response)
         assert ContactPoint.objects.count() == 2
 
-    def test_contact_point_api_invalid_email(self, api):
-        api.login()
+    def test_contact_point_api_invalid_email(self):
+        self.login()
         data = {"name": faker.word(), "email": faker.word(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert "email" in response.json["errors"]
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_missing_contact_information(self, api):
-        api.login()
+    def test_contact_point_missing_contact_information(self):
+        self.login()
         data = {"name": faker.word(), "role": "contact"}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert response.json["message"] == _(
             "At least an email or a contact form is required for a contact point"
         )
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_missing_role(self, api):
-        api.login()
+    def test_contact_point_missing_role(self):
+        self.login()
         data = {"name": faker.word(), "email": faker.email()}
-        response = api.post(url_for("api.contact_points"), data=data)
+        response = self.post(url_for("api.contact_points"), data=data)
         assert400(response)
         assert (
             response.json["message"]
@@ -154,70 +148,70 @@ class ContactPointAPITest:
         )
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_no_need_for_email_for_role_other_than_contact(self, api):
-        api.login()
+    def test_contact_point_no_need_for_email_for_role_other_than_contact(self):
+        self.login()
         roles_other_than_contact = [role_ for role_ in CONTACT_ROLES.keys() if role_ != "contact"]
         for index, role in enumerate(roles_other_than_contact):
             data = {"name": faker.word(), "role": role}
-            response = api.post(url_for("api.contact_points"), data=data)
+            response = self.post(url_for("api.contact_points"), data=data)
             assert201(response)
             assert ContactPoint.objects.count() == index + 1
 
-    def test_contact_point_api_update(self, api):
-        user = api.login()
+    def test_contact_point_api_update(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         contact_point = ContactPointFactory(organization=org)
         data = contact_point.to_dict()
         data["email"] = "new.email@newdomain.com"
-        response = api.put(url_for("api.contact_point", contact_point=contact_point), data)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point), data)
         assert200(response)
         assert ContactPoint.objects.count() == 1
         assert ContactPoint.objects.first().email == "new.email@newdomain.com"
 
-    def test_contact_point_api_update_to_existing_contact_point(self, api):
-        user = api.login()
+    def test_contact_point_api_update_to_existing_contact_point(self):
+        user = self.login()
         contact_point_a = ContactPointFactory(email="a@example.org", owner=user)
         contact_point_b = ContactPointFactory(email="b@example.org", owner=user)
 
         data_b = contact_point_b.to_dict()
-        response = api.put(url_for("api.contact_point", contact_point=contact_point_a), data_b)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point_a), data_b)
         assert400(response)
         assert ContactPoint.objects.count() == 2
 
         contact_point_a.reload()
         assert contact_point_a.email == "a@example.org"
 
-    def test_contact_point_api_update_forbidden(self, api):
-        api.login()
+    def test_contact_point_api_update_forbidden(self):
+        self.login()
         org = OrganizationFactory()
         contact_point = ContactPointFactory(organization=org)
         data = contact_point.to_dict()
         data["email"] = "new.email@newdomain.com"
-        response = api.put(url_for("api.contact_point", contact_point=contact_point), data)
+        response = self.put(url_for("api.contact_point", contact_point=contact_point), data)
         assert403(response)
         assert ContactPoint.objects.count() == 1
         assert ContactPoint.objects.first().email == contact_point.email
 
-    def test_contact_point_api_delete(self, api):
-        user = api.login()
+    def test_contact_point_api_delete(self):
+        user = self.login()
         member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         contact_point = ContactPointFactory(organization=org)
-        response = api.delete(url_for("api.contact_point", contact_point=contact_point))
+        response = self.delete(url_for("api.contact_point", contact_point=contact_point))
         assert204(response)
         assert ContactPoint.objects.count() == 0
 
-    def test_contact_point_roles_list(self, api):
+    def test_contact_point_roles_list(self):
         """It should fetch the contact point roles list from the API"""
-        response = api.get(url_for("api.contact_point_roles"))
+        response = self.get(url_for("api.contact_point_roles"))
         assert200(response)
         assert len(response.json) == len(CONTACT_ROLES)
 
-    def test_contact_point_api_delete_forbidden(self, api):
-        api.login()
+    def test_contact_point_api_delete_forbidden(self):
+        self.login()
         org = OrganizationFactory()
         contact_point = ContactPointFactory(organization=org)
-        response = api.delete(url_for("api.contact_point", contact_point=contact_point))
+        response = self.delete(url_for("api.contact_point", contact_point=contact_point))
         assert403(response)
         assert ContactPoint.objects.count() == 1

udata/tests/api/test_dataservices_api.py

@@ -6,21 +6,17 @@ from flask import url_for
 from werkzeug.test import TestResponse
 
 import udata.core.organization.constants as org_constants
-from udata.core.dataservices.constants import (
-    DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-    DATASERVICE_ACCESS_AUDIENCE_COMPANY,
-    DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
-    DATASERVICE_ACCESS_AUDIENCE_YES,
-    DATASERVICE_ACCESS_TYPE_OPEN,
-    DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
-    DATASERVICE_ACCESS_TYPE_RESTRICTED,
+from udata.core.access_type.constants import (
+    AccessAudienceCondition,
+    AccessAudienceType,
+    AccessType,
 )
 from udata.core.dataservices.factories import DataserviceFactory
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.factories import DatasetFactory, LicenseFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.organization.models import Member
-from udata.core.topic.factories import TopicElementFactory, TopicFactory
+from udata.core.topic.factories import ReuseFactory, TopicElementFactory, TopicFactory
 from udata.core.user.factories import AdminFactory, UserFactory
 from udata.i18n import gettext as _
 from udata.tests.helpers import assert200, assert400, assert410
@@ -34,8 +30,6 @@ def dataservice_in_response(response: TestResponse, dataservice: Dataservice) ->
 
 
 class DataserviceAPITest(APITestCase):
-    modules = []
-
     def test_dataservice_api_get(self):
         """It should fetch a dataservice from the API"""
         dataservice = DataserviceFactory()
@@ -105,6 +99,34 @@ class DataserviceAPITest(APITestCase):
         assert len(response.json["data"]) == 1
         assert response.json["data"][0]["id"] == str(topic_dataservice.id)
 
+        # filter on reuse
+        reuse_dataservice = DataserviceFactory()
+        reuse = ReuseFactory(dataservices=[reuse_dataservice])
+        response = self.get(url_for("api.dataservices", reuse=reuse.id))
+        assert200(response)
+        assert len(response.json["data"]) == 1
+        assert response.json["data"][0]["id"] == str(reuse_dataservice.id)
+
+    def test_dataservices_topic_filter_errors(self):
+        # non-existing
+        response = self.get(url_for("api.dataservices", topic="690c7f48ec85adaa376c1e93"))
+        assert200(response)
+
+        # not an object ID
+        response = self.get(url_for("api.dataservices", topic="xxx"))
+        assert400(response)
+        assert "`topic` must be an identifier" in response.json["message"]
+
+    def test_dataservices_reuse_filter_errors(self):
+        # non-existing
+        response = self.get(url_for("api.dataservices", reuse="690c7f48ec85adaa376c1e93"))
+        assert200(response)
+
+        # not an object ID
+        response = self.get(url_for("api.dataservices", reuse="xxx"))
+        assert400(response)
+        assert "`reuse` must be an identifier" in response.json["message"]
+
     def test_dataservice_api_create(self):
         user = self.login()
         datasets = DatasetFactory.create_batch(3)
@@ -140,15 +162,15 @@ class DataserviceAPITest(APITestCase):
                 "extras": {
                     "foo": "bar",
                 },
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
                 "access_audiences": [
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
                     },
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_COMPANY,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                        "role": AccessAudienceType.COMPANY,
+                        "condition": AccessAudienceCondition.UNDER_CONDITIONS,
                     },
                 ],
             },
@@ -164,20 +186,18 @@ class DataserviceAPITest(APITestCase):
         self.assertEqual(
             response.json["self_api_url"], "http://local.test/api/1/dataservices/updated-title/"
         )
-        self.assertEqual(response.json["access_type"], DATASERVICE_ACCESS_TYPE_RESTRICTED)
+        self.assertEqual(response.json["access_type"], AccessType.RESTRICTED)
         self.assertEqual(len(response.json["access_audiences"]), 2)
         self.assertEqual(
-            response.json["access_audiences"][0]["role"], DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION
-        )
-        self.assertEqual(
-            response.json["access_audiences"][0]["condition"], DATASERVICE_ACCESS_AUDIENCE_YES
+            response.json["access_audiences"][0]["role"], AccessAudienceType.ADMINISTRATION
         )
         self.assertEqual(
-            response.json["access_audiences"][1]["role"], DATASERVICE_ACCESS_AUDIENCE_COMPANY
+            response.json["access_audiences"][0]["condition"], AccessAudienceCondition.YES
         )
+        self.assertEqual(response.json["access_audiences"][1]["role"], AccessAudienceType.COMPANY)
         self.assertEqual(
             response.json["access_audiences"][1]["condition"],
-            DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+            AccessAudienceCondition.UNDER_CONDITIONS,
         )
         # metadata_modified_at should have been updated during the patch
         self.assertNotEqual(
@@ -326,7 +346,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "B",
                 "base_api_url": "https://example.org/B",
                 "datasets": [dataset_b.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_OPEN,
+                "access_type": AccessType.OPEN,
             },
         )
         self.post(
@@ -335,7 +355,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "C",
                 "base_api_url": "https://example.org/C",
                 "datasets": [dataset_a.id, dataset_b.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_OPEN_WITH_ACCOUNT,
+                "access_type": AccessType.OPEN_WITH_ACCOUNT,
             },
         )
         self.post(
@@ -344,7 +364,7 @@ class DataserviceAPITest(APITestCase):
                 "title": "A",
                 "base_api_url": "https://example.org/A",
                 "datasets": [dataset_a.id],
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
             },
         )
         self.post(
@@ -407,7 +427,7 @@ class DataserviceAPITest(APITestCase):
         self.assertEqual(response.json["data"][0]["title"], "A")
         self.assertEqual(response.json["data"][1]["title"], "C")
 
-        response = self.get(url_for("api.dataservices", access_type=DATASERVICE_ACCESS_TYPE_OPEN))
+        response = self.get(url_for("api.dataservices", access_type=AccessType.OPEN))
         self.assert200(response)
 
         print(response.json)
@@ -598,15 +618,15 @@ class DataserviceAPITest(APITestCase):
             {
                 "title": "My title",
                 "base_api_url": "https://example.org",
-                "access_type": DATASERVICE_ACCESS_TYPE_RESTRICTED,
+                "access_type": AccessType.RESTRICTED,
                 "access_audiences": [
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.YES,
                     },
                     {
-                        "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                        "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                        "role": AccessAudienceType.ADMINISTRATION,
+                        "condition": AccessAudienceCondition.UNDER_CONDITIONS,
                     },
                 ],
             },
@@ -622,15 +642,15 @@ class DataserviceAPITest(APITestCase):
         dataservice = DataserviceFactory(owner=user, organization=original_org)
 
         data = dataservice.to_dict()
-        data["access_type"] = DATASERVICE_ACCESS_TYPE_RESTRICTED
+        data["access_type"] = AccessType.RESTRICTED
         data["access_audiences"] = [
             {
-                "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                "condition": DATASERVICE_ACCESS_AUDIENCE_YES,
+                "role": AccessAudienceType.ADMINISTRATION,
+                "condition": AccessAudienceCondition.YES,
             },
             {
-                "role": DATASERVICE_ACCESS_AUDIENCE_ADMINISTRATION,
-                "condition": DATASERVICE_ACCESS_AUDIENCE_UNDER_CONDITIONS,
+                "role": AccessAudienceType.ADMINISTRATION,
+                "condition": AccessAudienceCondition.UNDER_CONDITIONS,
             },
         ]
         response = self.patch(url_for("api.dataservice", dataservice=dataservice), data)