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

udata/tests/api/test_tags_api.py

@@ -1,77 +1,70 @@
 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.utils import faker
 from udata.tests.helpers import assert200
+from udata.utils import faker
 
 
 @pytest.mark.frontend
 class TagsAPITest:
     def test_suggest_tags_api(self, api):
-        '''It should suggest tags'''
+        """It should suggest tags"""
         for i in range(3):
-            tags = [faker.word(), faker.word(), 'test',
-                    'test-{0}'.format(i)]
+            tags = [faker.word(), faker.word(), "test", "test-{0}".format(i)]
             ReuseFactory(tags=tags, visible=True)
             DatasetFactory(tags=tags, visible=True)
 
         count_tags()
 
-        response = api.get(url_for('api.suggest_tags'),
-                            qs={'q': 'tes', 'size': '5'})
+        response = api.get(url_for("api.suggest_tags"), qs={"q": "tes", "size": "5"})
         assert200(response)
 
         assert len(response.json) <= 5
         assert len(response.json) > 1
-        assert response.json[0]['text'] == 'test'
+        assert response.json[0]["text"] == "test"
 
         for suggestion in response.json:
-            assert 'text' in suggestion
-            assert 'tes' in suggestion['text']
+            assert "text" in suggestion
+            assert "tes" in suggestion["text"]
 
     def test_suggest_tags_api_with_unicode(self, api):
-        '''It should suggest tags'''
+        """It should suggest tags"""
         for i in range(3):
-            tags = [faker.word(), faker.word(), 'testé',
-                    'testé-{0}'.format(i)]
+            tags = [faker.word(), faker.word(), "testé", "testé-{0}".format(i)]
             ReuseFactory(tags=tags, visible=True)
             DatasetFactory(tags=tags, visible=True)
 
         count_tags()
 
-        response = api.get(url_for('api.suggest_tags'),
-                           qs={'q': 'testé', 'size': '5'})
+        response = api.get(url_for("api.suggest_tags"), qs={"q": "testé", "size": "5"})
         assert200(response)
 
         assert len(response.json) <= 5
         assert len(response.json) > 1
-        assert response.json[0]['text'] == 'teste'
+        assert response.json[0]["text"] == "teste"
 
         for suggestion in response.json:
-            assert 'text' in suggestion
-            assert 'teste' in suggestion['text']
+            assert "text" in suggestion
+            assert "teste" in suggestion["text"]
 
     def test_suggest_tags_api_no_match(self, api):
-        '''It should not provide tag suggestion if no match'''
+        """It should not provide tag suggestion if no match"""
         for i in range(3):
-            tags = ['aaaa', 'aaaa-{0}'.format(i)]
+            tags = ["aaaa", "aaaa-{0}".format(i)]
             ReuseFactory(tags=tags, visible=True)
             DatasetFactory(tags=tags, visible=True)
 
         count_tags()
 
-        response = api.get(url_for('api.suggest_tags'),
-                           qs={'q': 'bbbb', 'size': '5'})
+        response = api.get(url_for("api.suggest_tags"), qs={"q": "bbbb", "size": "5"})
         assert200(response)
         assert len(response.json) is 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'})
+        """It should not provide tag suggestion if no data"""
+        response = api.get(url_for("api.suggest_tags"), qs={"q": "bbbb", "size": "5"})
         assert200(response)
         assert len(response.json) is 0

udata/tests/api/test_topics_api.py

@@ -6,7 +6,7 @@ from udata.core.spatial.models import spatial_granularities
 from udata.core.topic.factories import TopicFactory
 from udata.core.topic.models import Topic
 from udata.core.user.factories import UserFactory
-from udata.models import Member, Discussion
+from udata.models import Discussion, Member
 from udata.tests.api.test_datasets_api import SAMPLE_GEOM
 from udata.tests.features.territories import create_geozones_fixtures
 
@@ -17,124 +17,121 @@ class TopicsAPITest(APITestCase):
     modules = []
 
     def test_topic_api_list(self):
-        '''It should fetch a topic list from the API'''
+        """It should fetch a topic list from the API"""
         owner = UserFactory()
         org = OrganizationFactory()
         paca, _, _ = create_geozones_fixtures()
 
-        tag_topic = TopicFactory(tags=['energy'])
-        name_topic = TopicFactory(name='topic-for-query')
+        tag_topic = TopicFactory(tags=["energy"])
+        name_topic = TopicFactory(name="topic-for-query")
         private_topic = TopicFactory(private=True)
         geozone_topic = TopicFactory(spatial=SpatialCoverageFactory(zones=[paca.id]))
-        granularity_topic = TopicFactory(
-            spatial=SpatialCoverageFactory(granularity='country')
-        )
+        granularity_topic = TopicFactory(spatial=SpatialCoverageFactory(granularity="country"))
         owner_topic = TopicFactory(owner=owner)
         org_topic = TopicFactory(organization=org)
 
-        response = self.get(url_for('api.topics'))
+        response = self.get(url_for("api.topics"))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 6)
+        self.assertEqual(len(response.json["data"]), 6)
 
-        response = self.get(url_for('api.topics', q='topic-for'))
+        response = self.get(url_for("api.topics", q="topic-for"))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertEqual(response.json['data'][0]['id'], str(name_topic.id))
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertEqual(response.json["data"][0]["id"], str(name_topic.id))
 
-        response = self.get(url_for('api.topics', tag='energy'))
+        response = self.get(url_for("api.topics", tag="energy"))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertEqual(response.json['data'][0]['id'], str(tag_topic.id))
-        datasets = response.json['data'][0]['datasets']
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertEqual(response.json["data"][0]["id"], str(tag_topic.id))
+        datasets = response.json["data"][0]["datasets"]
         self.assertEqual(len(datasets), 3)
         for dataset, expected in zip(datasets, [d.fetch() for d in tag_topic.datasets]):
-            self.assertEqual(dataset['id'], str(expected.id))
-            self.assertEqual(dataset['title'], str(expected.title))
-            self.assertIsNotNone(dataset['page'])
-            self.assertIsNotNone(dataset['uri'])
-        reuses = response.json['data'][0]['reuses']
+            self.assertEqual(dataset["id"], str(expected.id))
+            self.assertEqual(dataset["title"], str(expected.title))
+            self.assertIsNotNone(dataset["page"])
+            self.assertIsNotNone(dataset["uri"])
+        reuses = response.json["data"][0]["reuses"]
         for reuse, expected in zip(reuses, [r.fetch() for r in tag_topic.reuses]):
-            self.assertEqual(reuse['id'], str(expected.id))
-            self.assertEqual(reuse['title'], str(expected.title))
-            self.assertIsNotNone(reuse['page'])
-            self.assertIsNotNone(reuse['uri'])
+            self.assertEqual(reuse["id"], str(expected.id))
+            self.assertEqual(reuse["title"], str(expected.title))
+            self.assertIsNotNone(reuse["page"])
+            self.assertIsNotNone(reuse["uri"])
         self.assertEqual(len(reuses), 3)
 
-        response = self.get(url_for('api.topics', include_private='true'))
+        response = self.get(url_for("api.topics", include_private="true"))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 7)
-        self.assertIn(str(private_topic.id), [t['id'] for t in response.json['data']])
+        self.assertEqual(len(response.json["data"]), 7)
+        self.assertIn(str(private_topic.id), [t["id"] for t in response.json["data"]])
 
-        response = self.get(url_for('api.topics', geozone=paca.id))
+        response = self.get(url_for("api.topics", geozone=paca.id))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertIn(str(geozone_topic.id), [t['id'] for t in response.json['data']])
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertIn(str(geozone_topic.id), [t["id"] for t in response.json["data"]])
 
-        response = self.get(url_for('api.topics', granularity='country'))
+        response = self.get(url_for("api.topics", granularity="country"))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertIn(str(granularity_topic.id), [t['id'] for t in response.json['data']])
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertIn(str(granularity_topic.id), [t["id"] for t in response.json["data"]])
 
-        response = self.get(url_for('api.topics', owner=owner.id))
+        response = self.get(url_for("api.topics", owner=owner.id))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertIn(str(owner_topic.id), [t['id'] for t in response.json['data']])
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertIn(str(owner_topic.id), [t["id"] for t in response.json["data"]])
 
-        response = self.get(url_for('api.topics', organization=org.id))
+        response = self.get(url_for("api.topics", organization=org.id))
         self.assert200(response)
-        self.assertEqual(len(response.json['data']), 1)
-        self.assertIn(str(org_topic.id), [t['id'] for t in response.json['data']])
-
+        self.assertEqual(len(response.json["data"]), 1)
+        self.assertIn(str(org_topic.id), [t["id"] for t in response.json["data"]])
 
     def test_topic_api_get(self):
-        '''It should fetch a topic from the API'''
+        """It should fetch a topic from the API"""
         topic = TopicFactory()
-        response = self.get(url_for('api.topic', topic=topic))
+        response = self.get(url_for("api.topic", topic=topic))
         self.assert200(response)
 
         data = response.json
-        self.assertIn('spatial', data)
+        self.assertIn("spatial", data)
 
-        for dataset, expected in zip(data['datasets'], [d.fetch() for d in topic.datasets]):
-            self.assertEqual(dataset['id'], str(expected.id))
-            self.assertEqual(dataset['title'], str(expected.title))
-            self.assertIsNotNone(dataset['page'])
-            self.assertIsNotNone(dataset['uri'])
+        for dataset, expected in zip(data["datasets"], [d.fetch() for d in topic.datasets]):
+            self.assertEqual(dataset["id"], str(expected.id))
+            self.assertEqual(dataset["title"], str(expected.title))
+            self.assertIsNotNone(dataset["page"])
+            self.assertIsNotNone(dataset["uri"])
 
-        for reuse, expected in zip(data['reuses'], [r.fetch() for r in topic.reuses]):
-            self.assertEqual(reuse['id'], str(expected.id))
-            self.assertEqual(reuse['title'], str(expected.title))
-            self.assertIsNotNone(reuse['page'])
-            self.assertIsNotNone(reuse['uri'])
+        for reuse, expected in zip(data["reuses"], [r.fetch() for r in topic.reuses]):
+            self.assertEqual(reuse["id"], str(expected.id))
+            self.assertEqual(reuse["title"], str(expected.title))
+            self.assertIsNotNone(reuse["page"])
+            self.assertIsNotNone(reuse["uri"])
 
-        self.assertIsNotNone(data.get('created_at'))
-        self.assertIsNotNone(data.get('last_modified'))
+        self.assertIsNotNone(data.get("created_at"))
+        self.assertIsNotNone(data.get("last_modified"))
 
     def test_topic_api_create(self):
-        '''It should create a topic from the API'''
+        """It should create a topic from the API"""
         data = TopicFactory.as_dict()
-        data['datasets'] = [str(d.id) for d in data['datasets']]
-        data['reuses'] = [str(r.id) for r in data['reuses']]
+        data["datasets"] = [str(d.id) for d in data["datasets"]]
+        data["reuses"] = [str(r.id) for r in data["reuses"]]
         self.login()
-        response = self.post(url_for('api.topics'), data)
+        response = self.post(url_for("api.topics"), data)
         self.assert201(response)
         self.assertEqual(Topic.objects.count(), 1)
         topic = Topic.objects.first()
-        for dataset, expected in zip(topic.datasets, data['datasets']):
+        for dataset, expected in zip(topic.datasets, data["datasets"]):
             self.assertEqual(str(dataset.id), expected)
-        for reuse, expected in zip(topic.reuses, data['reuses']):
+        for reuse, expected in zip(topic.reuses, data["reuses"]):
             self.assertEqual(str(reuse.id), expected)
 
     def test_topic_api_create_as_org(self):
-        '''It should create a topic as organization from the API'''
+        """It should create a topic as organization from the API"""
         data = TopicFactory.as_dict()
-        data['datasets'] = [str(d.id) for d in data['datasets']]
-        data['reuses'] = [str(r.id) for r in data['reuses']]
+        data["datasets"] = [str(d.id) for d in data["datasets"]]
+        data["reuses"] = [str(r.id) for r in data["reuses"]]
         user = self.login()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
-        data['organization'] = str(org.id)
-        response = self.post(url_for('api.topics'), data)
+        data["organization"] = str(org.id)
+        response = self.post(url_for("api.topics"), data)
         self.assert201(response)
         self.assertEqual(Topic.objects.count(), 1)
 
@@ -146,15 +143,15 @@ class TopicsAPITest(APITestCase):
         paca, _, _ = create_geozones_fixtures()
         granularity = spatial_granularities[0][0]
         data = TopicFactory.as_dict()
-        data['datasets'] = [str(d.id) for d in data['datasets']]
-        data['reuses'] = [str(r.id) for r in data['reuses']]
-        data['spatial'] = {
-            'zones': [paca.id],
-            'geom': SAMPLE_GEOM,
-            'granularity': granularity,
+        data["datasets"] = [str(d.id) for d in data["datasets"]]
+        data["reuses"] = [str(r.id) for r in data["reuses"]]
+        data["spatial"] = {
+            "zones": [paca.id],
+            "geom": SAMPLE_GEOM,
+            "granularity": granularity,
         }
         self.login()
-        response = self.post(url_for('api.topics'), data)
+        response = self.post(url_for("api.topics"), data)
         self.assert201(response)
         self.assertEqual(Topic.objects.count(), 1)
         topic = Topic.objects.first()
@@ -163,58 +160,61 @@ class TopicsAPITest(APITestCase):
         self.assertEqual(topic.spatial.granularity, granularity)
 
     def test_topic_api_update(self):
-        '''It should update a topic from the API'''
+        """It should update a topic from the API"""
         owner = self.login()
         topic = TopicFactory(owner=owner)
         data = topic.to_dict()
-        data['description'] = 'new description'
-        response = self.put(url_for('api.topic', topic=topic), data)
+        data["description"] = "new description"
+        response = self.put(url_for("api.topic", topic=topic), data)
         self.assert200(response)
         self.assertEqual(Topic.objects.count(), 1)
         topic = Topic.objects.first()
-        self.assertEqual(topic.description, 'new description')
+        self.assertEqual(topic.description, "new description")
         self.assertGreater(topic.last_modified, topic.created_at)
 
     def test_topic_api_update_perm(self):
-        '''It should not update a topic from the API'''
+        """It should not update a topic from the API"""
         owner = UserFactory()
         topic = TopicFactory(owner=owner)
         user = self.login()
         data = topic.to_dict()
-        data['owner'] = user.to_dict()
-        response = self.put(url_for('api.topic', topic=topic), data)
+        data["owner"] = user.to_dict()
+        response = self.put(url_for("api.topic", topic=topic), data)
         self.assert403(response)
 
     def test_topic_api_delete(self):
-        '''It should delete a topic from the API'''
+        """It should delete a topic from the API"""
         owner = self.login()
         topic = TopicFactory(owner=owner)
 
         with self.api_user():
-            response = self.post(url_for('api.discussions'), {
-                'title': 'test title',
-                'comment': 'bla bla',
-                'subject': {
-                    'class': 'Topic',
-                    'id': topic.id,
-                }
-            })
+            response = self.post(
+                url_for("api.discussions"),
+                {
+                    "title": "test title",
+                    "comment": "bla bla",
+                    "subject": {
+                        "class": "Topic",
+                        "id": topic.id,
+                    },
+                },
+            )
         self.assert201(response)
 
         discussions = Discussion.objects(subject=topic)
         self.assertEqual(len(discussions), 1)
 
         with self.api_user():
-            response = self.delete(url_for('api.topic', topic=topic))
+            response = self.delete(url_for("api.topic", topic=topic))
         self.assertStatus(response, 204)
 
         self.assertEqual(Topic.objects.count(), 0)
         self.assertEqual(Discussion.objects.count(), 0)
 
     def test_topic_api_delete_perm(self):
-        '''It should not delete a topic from the API'''
+        """It should not delete a topic from the API"""
         owner = UserFactory()
         topic = TopicFactory(owner=owner)
         with self.api_user():
-            response = self.delete(url_for('api.topic', topic=topic))
+            response = self.delete(url_for("api.topic", topic=topic))
         self.assertStatus(response, 403)

udata/tests/api/test_transfer_api.py

@@ -1,11 +1,10 @@
 from bson import ObjectId
-from mock import patch
-
 from flask import url_for
+from mock import patch
 
 from udata.core.dataset.factories import DatasetFactory
-from udata.features.transfer.factories import TransferFactory
 from udata.core.user.factories import UserFactory
+from udata.features.transfer.factories import TransferFactory
 from udata.utils import faker
 
 from . import APITestCase
@@ -14,7 +13,7 @@ from . import APITestCase
 class TransferAPITest(APITestCase):
     modules = []
 
-    @patch('udata.features.transfer.api.request_transfer')
+    @patch("udata.features.transfer.api.request_transfer")
     def test_request_dataset_transfer(self, action):
         user = self.login()
         recipient = UserFactory()
@@ -22,23 +21,23 @@ class TransferAPITest(APITestCase):
         comment = faker.sentence()
 
         action.return_value = TransferFactory(
-            owner=user,
-            recipient=recipient,
-            subject=dataset,
-            comment=comment
+            owner=user, recipient=recipient, subject=dataset, comment=comment
         )
 
-        response = self.post(url_for('api.transfers'), {
-            'subject': {
-                'class': 'Dataset',
-                'id': str(dataset.id),
-            },
-            'recipient': {
-                'class': 'User',
-                'id': str(recipient.id),
+        response = self.post(
+            url_for("api.transfers"),
+            {
+                "subject": {
+                    "class": "Dataset",
+                    "id": str(dataset.id),
+                },
+                "recipient": {
+                    "class": "User",
+                    "id": str(recipient.id),
+                },
+                "comment": comment,
             },
-            'comment': comment
-        })
+        )
 
         self.assert201(response)
 
@@ -46,60 +45,66 @@ class TransferAPITest(APITestCase):
 
         data = response.json
 
-        self.assertEqual(data['recipient']['id'], str(recipient.id))
-        self.assertEqual(data['recipient']['class'], 'User')
+        self.assertEqual(data["recipient"]["id"], str(recipient.id))
+        self.assertEqual(data["recipient"]["class"], "User")
 
-        self.assertEqual(data['subject']['id'], str(dataset.id))
-        self.assertEqual(data['subject']['class'], 'Dataset')
+        self.assertEqual(data["subject"]["id"], str(dataset.id))
+        self.assertEqual(data["subject"]["class"], "Dataset")
 
-        self.assertEqual(data['owner']['id'], str(user.id))
-        self.assertEqual(data['owner']['class'], 'User')
+        self.assertEqual(data["owner"]["id"], str(user.id))
+        self.assertEqual(data["owner"]["class"], "User")
 
-        self.assertEqual(data['comment'], comment)
-        self.assertEqual(data['status'], 'pending')
+        self.assertEqual(data["comment"], comment)
+        self.assertEqual(data["status"], "pending")
 
     def test_400_on_bad_subject(self):
         user = self.login()
         recipient = UserFactory()
         comment = faker.sentence()
 
-        response = self.post(url_for('api.transfers'), {
-            'subject': {
-                'class': 'Dataset',
-                'id': str(ObjectId()),
-            },
-            'recipient': {
-                'class': 'User',
-                'id': str(recipient.id),
+        response = self.post(
+            url_for("api.transfers"),
+            {
+                "subject": {
+                    "class": "Dataset",
+                    "id": str(ObjectId()),
+                },
+                "recipient": {
+                    "class": "User",
+                    "id": str(recipient.id),
+                },
+                "comment": comment,
             },
-            'comment': comment
-        })
+        )
 
         self.assert400(response)
 
         data = response.json
 
-        self.assertIn('subject', data['errors'])
+        self.assertIn("subject", data["errors"])
 
     def test_400_on_bad_recipient(self):
         user = self.login()
         dataset = DatasetFactory(owner=user)
         comment = faker.sentence()
 
-        response = self.post(url_for('api.transfers'), {
-            'subject': {
-                'class': 'Dataset',
-                'id': str(dataset.id),
+        response = self.post(
+            url_for("api.transfers"),
+            {
+                "subject": {
+                    "class": "Dataset",
+                    "id": str(dataset.id),
+                },
+                "recipient": {
+                    "class": "User",
+                    "id": str(ObjectId()),
+                },
+                "comment": comment,
             },
-            'recipient': {
-                'class': 'User',
-                'id': str(ObjectId()),
-            },
-            'comment': comment
-        })
+        )
 
         self.assert400(response)
 
         data = response.json
 
-        self.assertIn('recipient', data['errors'])
+        self.assertIn("recipient", data["errors"])