udata 9.1.2.dev30355__py2.py3-none-any.whl → 9.1.2.dev30382__py2.py3-none-any.whl

udata/tests/api/test_base_api.py

@@ -1,69 +1,67 @@
 from flask import url_for
 
-from udata.api import api, API
+from udata.api import API, api
 from udata.forms import Form, fields
 
 from . import APITestCase
 
-ns = api.namespace('fake-ns', 'A Fake namespace')
+ns = api.namespace("fake-ns", "A Fake namespace")
 
 
-@ns.route('/options', endpoint='fake-options')
+@ns.route("/options", endpoint="fake-options")
 class FakeAPI(API):
     def get(self):
-        return {'success': True}
+        return {"success": True}
 
 
-@ns.route('/fake-form', endpoint='fake-form')
+@ns.route("/fake-form", endpoint="fake-form")
 class FakeFormAPI(API):
     def post(self):
         class FakeForm(Form):
             pass
+
         api.validate(FakeForm)
-        return {'success': True}
+        return {"success": True}
 
 
 class OptionsCORSTest(APITestCase):
     def test_should_allow_options_and_cors(self):
-        '''Should allow OPTIONS operation and give cors parameters'''
-        response = self.client.options(url_for('api.fake-options'))
+        """Should allow OPTIONS operation and give cors parameters"""
+        response = self.client.options(url_for("api.fake-options"))
 
         self.assert200(response)
-        self.assertEqual(response.headers['Access-Control-Allow-Origin'], '*')
-        allowed_methods = response.headers['Allow']
-        self.assertIn('HEAD', allowed_methods)
-        self.assertIn('OPTIONS', allowed_methods)
-        self.assertIn('GET', allowed_methods)
+        self.assertEqual(response.headers["Access-Control-Allow-Origin"], "*")
+        allowed_methods = response.headers["Allow"]
+        self.assertIn("HEAD", allowed_methods)
+        self.assertIn("OPTIONS", allowed_methods)
+        self.assertIn("GET", allowed_methods)
 
         response = self.client.options(
-            url_for('api.fake-options'),
+            url_for("api.fake-options"),
             headers={
-                'Access-Control-Request-Method': 'GET',
-                'Authorization': 'Bearer YouWillNeverGuess',
-                'Access-Control-Request-Headers': 'Authorization'
-            }
+                "Access-Control-Request-Method": "GET",
+                "Authorization": "Bearer YouWillNeverGuess",
+                "Access-Control-Request-Headers": "Authorization",
+            },
         )
-        self.assertEqual(response.headers['Access-Control-Allow-Origin'], '*')
-        self.assertEqual(response.headers['Access-Control-Allow-Headers'], 'Authorization')
+        self.assertEqual(response.headers["Access-Control-Allow-Origin"], "*")
+        self.assertEqual(response.headers["Access-Control-Allow-Headers"], "Authorization")
         self.assertEqual(
-            response.headers['Access-Control-Allow-Methods'],
-            'DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT'
-            )
+            response.headers["Access-Control-Allow-Methods"],
+            "DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT",
+        )
 
 
 class JSONFormRequestTest(APITestCase):
     def test_non_json_content_type(self):
-        '''We expect JSON requests for forms and enforce it'''
-        response = self.client.post(url_for('api.fake-form'), {}, headers={
-            'Content-Type': 'multipart/form-data'
-        })
-        self.assert400(response)
-        self.assertEqual(
-            response.json,
-            {'errors': {'Content-Type': 'expecting application/json'}}
+        """We expect JSON requests for forms and enforce it"""
+        response = self.client.post(
+            url_for("api.fake-form"), {}, headers={"Content-Type": "multipart/form-data"}
         )
+        self.assert400(response)
+        self.assertEqual(response.json, {"errors": {"Content-Type": "expecting application/json"}})
 
     def test_json_content_type(self):
-        '''We expect JSON requests for forms and enforce it'''
-        response = self.post(url_for('api.fake-form'), {})
+        """We expect JSON requests for forms and enforce it"""
+        response = self.post(url_for("api.fake-form"), {})
         self.assert200(response)

udata/tests/api/test_contact_points.py

@@ -1,14 +1,12 @@
 import pytest
-
 from flask import url_for
 
-from udata.models import ContactPoint
 from udata.core.contact_point.factories import ContactPointFactory
-
+from udata.models import ContactPoint
 from udata.tests.helpers import assert200, assert204
 
 pytestmark = [
-    pytest.mark.usefixtures('clean_db'),
+    pytest.mark.usefixtures("clean_db"),
 ]
 
 
@@ -19,15 +17,15 @@ class ContactPointAPITest:
         user = api.login()
         contact_point = ContactPointFactory()
         data = contact_point.to_dict()
-        data['email'] = 'new.email@newdomain.com'
-        response = api.put(url_for('api.contact_point', contact_point=contact_point), data)
+        data["email"] = "new.email@newdomain.com"
+        response = api.put(url_for("api.contact_point", contact_point=contact_point), data)
         assert200(response)
         assert ContactPoint.objects.count() is 1
-        assert ContactPoint.objects.first().email == 'new.email@newdomain.com'
+        assert ContactPoint.objects.first().email == "new.email@newdomain.com"
 
     def test_contact_point_api_delete(self, api):
         user = api.login()
         contact_point = ContactPointFactory()
-        response = api.delete(url_for('api.contact_point', contact_point=contact_point))
+        response = api.delete(url_for("api.contact_point", contact_point=contact_point))
         assert204(response)
-        assert ContactPoint.objects.count() is 0
+        assert ContactPoint.objects.count() is 0

udata/tests/api/test_dataservices_api.py

@@ -1,14 +1,15 @@
 from flask import url_for
 
 from udata.core.dataservices.models import Dataservice
-from udata.core.dataset.factories import (DatasetFactory, LicenseFactory)
-from udata.i18n import gettext as _
-from udata.core.user.factories import UserFactory
+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.user.factories import UserFactory
+from udata.i18n import gettext as _
 
 from . import APITestCase
 
+
 class DataserviceAPITest(APITestCase):
     modules = []
 
@@ -17,244 +18,296 @@ class DataserviceAPITest(APITestCase):
         datasets = DatasetFactory.create_batch(3)
         license = LicenseFactory.create()
 
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My API',
-            'base_api_url': 'https://example.org',
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My API",
+                "base_api_url": "https://example.org",
+            },
+        )
         self.assert201(response)
         self.assertEqual(Dataservice.objects.count(), 1)
 
         dataservice = Dataservice.objects.first()
 
-        response = self.get(url_for('api.dataservice', dataservice=dataservice))
+        response = self.get(url_for("api.dataservice", dataservice=dataservice))
         self.assert200(response)
 
-        self.assertEqual(response.json['title'], 'My API')
-        self.assertEqual(response.json['base_api_url'], 'https://example.org')
-        self.assertEqual(response.json['owner']['id'], str(user.id))
-
-        response = self.patch(url_for('api.dataservice', dataservice=dataservice), {
-            'title': 'Updated title',
-            'tags': ['hello', 'world'],
-            'private': True,
-            'datasets': [datasets[0].id, datasets[2].id],
-            'license': license.id,
-            'extras': {
-                'foo': 'bar',
+        self.assertEqual(response.json["title"], "My API")
+        self.assertEqual(response.json["base_api_url"], "https://example.org")
+        self.assertEqual(response.json["owner"]["id"], str(user.id))
+
+        response = self.patch(
+            url_for("api.dataservice", dataservice=dataservice),
+            {
+                "title": "Updated title",
+                "tags": ["hello", "world"],
+                "private": True,
+                "datasets": [datasets[0].id, datasets[2].id],
+                "license": license.id,
+                "extras": {
+                    "foo": "bar",
+                },
             },
-        })
+        )
         self.assert200(response)
 
-        self.assertEqual(response.json['title'], 'Updated title')
-        self.assertEqual(response.json['base_api_url'], 'https://example.org')
-        self.assertEqual(response.json['tags'], ['hello', 'world'])
-        self.assertEqual(response.json['private'], True)
-        self.assertEqual(response.json['datasets'][0]['title'], datasets[0].title)
-        self.assertEqual(response.json['datasets'][1]['title'], datasets[2].title)
-        self.assertEqual(response.json['extras'], {
-            'foo': 'bar',
-        })
-        self.assertEqual(response.json['license'], license.title)
-        self.assertEqual(response.json['self_api_url'], 'http://local.test/api/1/dataservices/updated-title/')
+        self.assertEqual(response.json["title"], "Updated title")
+        self.assertEqual(response.json["base_api_url"], "https://example.org")
+        self.assertEqual(response.json["tags"], ["hello", "world"])
+        self.assertEqual(response.json["private"], True)
+        self.assertEqual(response.json["datasets"][0]["title"], datasets[0].title)
+        self.assertEqual(response.json["datasets"][1]["title"], datasets[2].title)
+        self.assertEqual(
+            response.json["extras"],
+            {
+                "foo": "bar",
+            },
+        )
+        self.assertEqual(response.json["license"], license.title)
+        self.assertEqual(
+            response.json["self_api_url"], "http://local.test/api/1/dataservices/updated-title/"
+        )
         dataservice.reload()
-        self.assertEqual(dataservice.title, 'Updated title')
-        self.assertEqual(dataservice.base_api_url, 'https://example.org')
-        self.assertEqual(dataservice.tags, ['hello', 'world'])
+        self.assertEqual(dataservice.title, "Updated title")
+        self.assertEqual(dataservice.base_api_url, "https://example.org")
+        self.assertEqual(dataservice.tags, ["hello", "world"])
         self.assertEqual(dataservice.private, True)
         self.assertEqual(dataservice.datasets[0].title, datasets[0].title)
         self.assertEqual(dataservice.datasets[1].title, datasets[2].title)
-        self.assertEqual(dataservice.extras, {
-            'foo': 'bar',
-        })
+        self.assertEqual(
+            dataservice.extras,
+            {
+                "foo": "bar",
+            },
+        )
         self.assertEqual(dataservice.license.title, license.title)
-        self.assertEqual(dataservice.self_api_url(), 'http://local.test/api/1/dataservices/updated-title/')
+        self.assertEqual(
+            dataservice.self_api_url(), "http://local.test/api/1/dataservices/updated-title/"
+        )
 
-        response = self.delete(url_for('api.dataservice', dataservice=dataservice))
+        response = self.delete(url_for("api.dataservice", dataservice=dataservice))
         self.assert204(response)
 
         self.assertEqual(Dataservice.objects.count(), 1)
 
         dataservice.reload()
-        self.assertEqual(dataservice.title, 'Updated title')
-        self.assertEqual(dataservice.base_api_url, 'https://example.org')
+        self.assertEqual(dataservice.title, "Updated title")
+        self.assertEqual(dataservice.base_api_url, "https://example.org")
         self.assertIsNotNone(dataservice.deleted_at)
 
         # response = self.get(url_for('api.dataservice', dataservice=dataservice))
         # self.assert410(response)
 
-
     def test_dataservice_api_index(self):
         dataset_a = DatasetFactory()
         dataset_b = DatasetFactory()
 
         self.login()
-        self.post(url_for('api.dataservices'), {
-            'title': 'B',
-            'base_api_url': 'https://example.org/B',
-            'datasets': [dataset_b.id],
-        })
-        self.post(url_for('api.dataservices'), {
-            'title': 'C',
-            'base_api_url': 'https://example.org/C',
-            'datasets': [dataset_a.id, dataset_b.id],
-        })
-        self.post(url_for('api.dataservices'), {
-            'title': 'A',
-            'base_api_url': 'https://example.org/A',
-            'datasets': [dataset_a.id],
-        })
-        self.post(url_for('api.dataservices'), {
-            'title': 'X',
-            'base_api_url': 'https://example.org/X',
-            'private': True,
-            'datasets': [dataset_a.id],
-        })
+        self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "B",
+                "base_api_url": "https://example.org/B",
+                "datasets": [dataset_b.id],
+            },
+        )
+        self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "C",
+                "base_api_url": "https://example.org/C",
+                "datasets": [dataset_a.id, dataset_b.id],
+            },
+        )
+        self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "A",
+                "base_api_url": "https://example.org/A",
+                "datasets": [dataset_a.id],
+            },
+        )
+        self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "X",
+                "base_api_url": "https://example.org/X",
+                "private": True,
+                "datasets": [dataset_a.id],
+            },
+        )
 
         self.assertEqual(Dataservice.objects.count(), 4)
 
-        response = self.get(url_for('api.dataservices'))
+        response = self.get(url_for("api.dataservices"))
         self.assert200(response)
 
-        self.assertEqual(response.json['previous_page'], None)
-        self.assertEqual(response.json['next_page'], None)
-        self.assertEqual(response.json['page'], 1)
-        self.assertEqual(response.json['total'], 3)
-        self.assertEqual(len(response.json['data']), 3)
-        self.assertEqual(response.json['data'][0]['title'], 'B')
-        self.assertEqual(response.json['data'][0]['datasets'][0]['id'], str(dataset_b.id))
-        self.assertEqual(response.json['data'][1]['title'], 'C')
-        self.assertEqual(response.json['data'][1]['datasets'][0]['id'], str(dataset_a.id))
-        self.assertEqual(response.json['data'][1]['datasets'][1]['id'], str(dataset_b.id))
-        self.assertEqual(response.json['data'][2]['title'], 'A')
-        self.assertEqual(response.json['data'][2]['datasets'][0]['id'], str(dataset_a.id))
-
-        response = self.get(url_for('api.dataservices', sort='title'))
+        self.assertEqual(response.json["previous_page"], None)
+        self.assertEqual(response.json["next_page"], None)
+        self.assertEqual(response.json["page"], 1)
+        self.assertEqual(response.json["total"], 3)
+        self.assertEqual(len(response.json["data"]), 3)
+        self.assertEqual(response.json["data"][0]["title"], "B")
+        self.assertEqual(response.json["data"][0]["datasets"][0]["id"], str(dataset_b.id))
+        self.assertEqual(response.json["data"][1]["title"], "C")
+        self.assertEqual(response.json["data"][1]["datasets"][0]["id"], str(dataset_a.id))
+        self.assertEqual(response.json["data"][1]["datasets"][1]["id"], str(dataset_b.id))
+        self.assertEqual(response.json["data"][2]["title"], "A")
+        self.assertEqual(response.json["data"][2]["datasets"][0]["id"], str(dataset_a.id))
+
+        response = self.get(url_for("api.dataservices", sort="title"))
         self.assert200(response)
 
-        self.assertEqual(response.json['previous_page'], None)
-        self.assertEqual(response.json['next_page'], None)
-        self.assertEqual(response.json['page'], 1)
-        self.assertEqual(response.json['total'], 3)
-        self.assertEqual(len(response.json['data']), 3)
-        self.assertEqual(response.json['data'][0]['title'], 'A')
-        self.assertEqual(response.json['data'][1]['title'], 'B')
-        self.assertEqual(response.json['data'][2]['title'], 'C')
+        self.assertEqual(response.json["previous_page"], None)
+        self.assertEqual(response.json["next_page"], None)
+        self.assertEqual(response.json["page"], 1)
+        self.assertEqual(response.json["total"], 3)
+        self.assertEqual(len(response.json["data"]), 3)
+        self.assertEqual(response.json["data"][0]["title"], "A")
+        self.assertEqual(response.json["data"][1]["title"], "B")
+        self.assertEqual(response.json["data"][2]["title"], "C")
 
-        response = self.get(url_for('api.dataservices', sort='-title'))
+        response = self.get(url_for("api.dataservices", sort="-title"))
         self.assert200(response)
 
-        self.assertEqual(response.json['previous_page'], None)
-        self.assertEqual(response.json['next_page'], None)
-        self.assertEqual(response.json['page'], 1)
-        self.assertEqual(response.json['total'], 3)
-        self.assertEqual(len(response.json['data']), 3)
-        self.assertEqual(response.json['data'][0]['title'], 'C')
-        self.assertEqual(response.json['data'][1]['title'], 'B')
-        self.assertEqual(response.json['data'][2]['title'], 'A')
+        self.assertEqual(response.json["previous_page"], None)
+        self.assertEqual(response.json["next_page"], None)
+        self.assertEqual(response.json["page"], 1)
+        self.assertEqual(response.json["total"], 3)
+        self.assertEqual(len(response.json["data"]), 3)
+        self.assertEqual(response.json["data"][0]["title"], "C")
+        self.assertEqual(response.json["data"][1]["title"], "B")
+        self.assertEqual(response.json["data"][2]["title"], "A")
 
-
-        response = self.get(url_for('api.dataservices', page_size=1))
+        response = self.get(url_for("api.dataservices", page_size=1))
         self.assert200(response)
 
-        self.assertEqual(response.json['previous_page'], None)
-        assert response.json['next_page'].endswith(url_for('api.dataservices', page_size=1, page=2))
-        self.assertEqual(response.json['page'], 1)
-        self.assertEqual(response.json['total'], 3)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertEqual(response.json['data'][0]['title'], 'B')
+        self.assertEqual(response.json["previous_page"], None)
+        assert response.json["next_page"].endswith(url_for("api.dataservices", page_size=1, page=2))
+        self.assertEqual(response.json["page"], 1)
+        self.assertEqual(response.json["total"], 3)
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertEqual(response.json["data"][0]["title"], "B")
 
-        response = self.get(url_for('api.dataservices', sort='title', dataset=str(dataset_a.id)))
+        response = self.get(url_for("api.dataservices", sort="title", dataset=str(dataset_a.id)))
         self.assert200(response)
 
-        self.assertEqual(response.json['total'], 2)
-        self.assertEqual(response.json['data'][0]['title'], 'A')
-        self.assertEqual(response.json['data'][0]['datasets'][0]['id'], str(dataset_a.id))
-        self.assertEqual(response.json['data'][1]['title'], 'C')
-        self.assertEqual(response.json['data'][1]['datasets'][0]['id'], str(dataset_a.id))
-        self.assertEqual(response.json['data'][1]['datasets'][1]['id'], str(dataset_b.id))
+        self.assertEqual(response.json["total"], 2)
+        self.assertEqual(response.json["data"][0]["title"], "A")
+        self.assertEqual(response.json["data"][0]["datasets"][0]["id"], str(dataset_a.id))
+        self.assertEqual(response.json["data"][1]["title"], "C")
+        self.assertEqual(response.json["data"][1]["datasets"][0]["id"], str(dataset_a.id))
+        self.assertEqual(response.json["data"][1]["datasets"][1]["id"], str(dataset_b.id))
 
     def test_dataservice_api_index_with_wrong_dataset_id(self):
-        response = self.get(url_for('api.dataservices', sort='title', dataset=str("xxx")))
+        response = self.get(url_for("api.dataservices", sort="title", dataset=str("xxx")))
         self.assert400(response)
 
     def test_dataservice_api_create_with_validation_error(self):
         self.login()
-        response = self.post(url_for('api.dataservices'), {
-            'base_api_url': 'https://example.org',
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "base_api_url": "https://example.org",
+            },
+        )
         self.assert400(response)
         self.assertEqual(Dataservice.objects.count(), 0)
 
     def test_dataservice_api_create_with_unkwown_license(self):
         self.login()
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'license': 'unwkown-license',
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "license": "unwkown-license",
+            },
+        )
         self.assert400(response)
-        self.assertEqual(response.json['errors']['license'], ["Unknown reference 'unwkown-license'"])
+        self.assertEqual(
+            response.json["errors"]["license"], ["Unknown reference 'unwkown-license'"]
+        )
         self.assertEqual(Dataservice.objects.count(), 0)
 
-
     def test_dataservice_api_create_with_unkwown_contact_point(self):
         self.login()
 
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'contact_point': '66212433e42ab56639ad516e',
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "contact_point": "66212433e42ab56639ad516e",
+            },
+        )
         self.assert400(response)
-        self.assertEqual(response.json['errors']['contact_point'], ["Unknown reference '66212433e42ab56639ad516e'"])
+        self.assertEqual(
+            response.json["errors"]["contact_point"],
+            ["Unknown reference '66212433e42ab56639ad516e'"],
+        )
         self.assertEqual(Dataservice.objects.count(), 0)
 
-
     def test_dataservice_api_create_with_custom_user_or_org(self):
         other = UserFactory()
-        other_member = Member(user=other, role='editor')
+        other_member = Member(user=other, role="editor")
         other_org = OrganizationFactory(members=[other_member])
 
         me = self.login()
-        me_member = Member(user=me, role='editor')
+        me_member = Member(user=me, role="editor")
         me_org = OrganizationFactory(members=[me_member])
 
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'owner': other.id,
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "owner": other.id,
+            },
+        )
         self.assert400(response)
-        self.assertEqual(response.json['errors']['owner'], [_("You can only set yourself as owner")])
+        self.assertEqual(
+            response.json["errors"]["owner"], [_("You can only set yourself as owner")]
+        )
         self.assertEqual(Dataservice.objects.count(), 0)
 
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'organization': other_org.id,
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "organization": other_org.id,
+            },
+        )
         self.assert400(response)
-        self.assertEqual(response.json['errors']['organization'], [_("Permission denied for this organization")])
+        self.assertEqual(
+            response.json["errors"]["organization"], [_("Permission denied for this organization")]
+        )
         self.assertEqual(Dataservice.objects.count(), 0)
 
-
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'owner': me.id,
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "owner": me.id,
+            },
+        )
         self.assert201(response)
-        dataservice = Dataservice.objects(id=response.json['id']).first()
+        dataservice = Dataservice.objects(id=response.json["id"]).first()
         self.assertEqual(dataservice.owner.id, me.id)
         self.assertEqual(dataservice.organization, None)
 
-
-        response = self.post(url_for('api.dataservices'), {
-            'title': 'My title',
-            'base_api_url': 'https://example.org',
-            'organization': me_org.id,
-        })
+        response = self.post(
+            url_for("api.dataservices"),
+            {
+                "title": "My title",
+                "base_api_url": "https://example.org",
+                "organization": me_org.id,
+            },
+        )
         self.assert201(response)
-        dataservice = Dataservice.objects(id=response.json['id']).first()
+        dataservice = Dataservice.objects(id=response.json["id"]).first()
         self.assertEqual(dataservice.owner, None)
-        self.assertEqual(dataservice.organization.id, me_org.id)
+        self.assertEqual(dataservice.organization.id, me_org.id)