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

udata/tests/cli/test_cli_base.py

@@ -1,16 +1,16 @@
 def test_cli_help(cli):
-    '''Should display help without errors'''
+    """Should display help without errors"""
     cli()
-    cli('-?')
-    cli('-h')
-    cli('--help')
+    cli("-?")
+    cli("-h")
+    cli("--help")
 
 
 def test_cli_log_and_printing(cli):
-    '''Should properly log and print'''
-    cli('test log')
+    """Should properly log and print"""
+    cli("test log")
 
 
 def test_cli_version(cli):
-    '''Should display version without errors'''
-    cli('--version')
+    """Should display version without errors"""
+    cli("--version")

udata/tests/cli/test_db_cli.py

@@ -5,53 +5,55 @@ import pytest
 
 @pytest.fixture
 def migrations(db):
-    db.migrations.insert_one({
-        'plugin': 'udata',
-        'filename': 'test.py',
-        'date': datetime.utcnow(),
-        'script': 'print("ok")',
-        'output': 'ok',
-    })
+    db.migrations.insert_one(
+        {
+            "plugin": "udata",
+            "filename": "test.py",
+            "date": datetime.utcnow(),
+            "script": 'print("ok")',
+            "output": "ok",
+        }
+    )
     return db.migrations
 
 
 def test_unrecord_with_complete_filename(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord udata test.py')
+    """Should display help without errors"""
+    result = cli("db unrecord udata test.py")
     assert result.exit_code == 0
     assert migrations.count_documents({}) == 0
 
 
 def test_unrecord_with_filename_without_extension(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord udata test')
+    """Should display help without errors"""
+    result = cli("db unrecord udata test")
     assert result.exit_code == 0
     assert migrations.count_documents({}) == 0
 
 
 def test_unrecord_with_single_parameter(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord udata:test.py')
+    """Should display help without errors"""
+    result = cli("db unrecord udata:test.py")
     assert result.exit_code == 0
     assert migrations.count_documents({}) == 0
 
 
 def test_unrecord_with_single_parameter_without_extension(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord udata:test')
+    """Should display help without errors"""
+    result = cli("db unrecord udata:test")
     assert result.exit_code == 0
     assert migrations.count_documents({}) == 0
 
 
 def test_unrecord_without_parameters(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord', check=False)
+    """Should display help without errors"""
+    result = cli("db unrecord", check=False)
     assert result.exit_code != 0
     assert migrations.count_documents({}) == 1
 
 
 def test_unrecord_with_too_many_parameters(cli, migrations):
-    '''Should display help without errors'''
-    result = cli('db unrecord udata test.py too many', check=False)
+    """Should display help without errors"""
+    result = cli("db unrecord udata test.py too many", check=False)
     assert result.exit_code != 0
     assert migrations.count_documents({}) == 1

udata/tests/dataservice/test_dataservice_tasks.py

@@ -1,24 +1,20 @@
 import pytest
 
+from udata.core.dataservices import tasks
 from udata.core.dataservices.models import Dataservice
 from udata.core.user.factories import UserFactory
-from udata.core.dataservices import tasks
 from udata.models import Discussion, Follow, Message, Transfer
 from udata.utils import faker
 
-
-pytestmark = pytest.mark.usefixtures('clean_db')
+pytestmark = pytest.mark.usefixtures("clean_db")
 
 
 def test_purge_dataservices():
     dataservices = [
         Dataservice.objects.create(
-            title='delete me',
-            base_api_url='https://example.com/api',
-            deleted_at='2016-01-01'),
-        Dataservice.objects.create(
-            title='keep me',
-            base_api_url='https://example.com/api'),
+            title="delete me", base_api_url="https://example.com/api", deleted_at="2016-01-01"
+        ),
+        Dataservice.objects.create(title="keep me", base_api_url="https://example.com/api"),
     ]
 
     user = UserFactory()
@@ -26,14 +22,14 @@ def test_purge_dataservices():
         owner=user,
         recipient=user,
         subject=dataservices[0],
-        comment='comment',
+        comment="comment",
     )
 
     discussion = Discussion.objects.create(
         subject=dataservices[0],
         user=user,
-        title='test discussion',
-        discussion=[Message(content=faker.sentence(), posted_by=user)]
+        title="test discussion",
+        discussion=[Message(content=faker.sentence(), posted_by=user)],
     )
 
     follower = Follow.objects.create(follower=user, following=dataservices[0])

udata/tests/dataset/test_csv_adapter.py

@@ -2,30 +2,33 @@ from datetime import datetime, timedelta
 
 import pytest
 
-from udata.core.dataset.csv import ResourcesCsvAdapter, DatasetCsvAdapter
+from udata.core.dataset.csv import DatasetCsvAdapter, ResourcesCsvAdapter
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.dataset.models import Dataset
 
 
 @pytest.mark.frontend
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class DatasetCSVAdapterTest:
-
     def test_resources_csv_adapter(self):
         date_created = datetime(2022, 12, 31)
         date_modified = date_created + timedelta(days=1)
         another_date = date_created + timedelta(days=42)
         dataset = DatasetFactory(
-            resources=[ResourceFactory(harvest={
-                'created_at': date_created,
-                'modified_at': date_modified,
-                'uri': 'http://domain.gouv.fr/dataset/uri',
-            })],
+            resources=[
+                ResourceFactory(
+                    harvest={
+                        "created_at": date_created,
+                        "modified_at": date_modified,
+                        "uri": "http://domain.gouv.fr/dataset/uri",
+                    }
+                )
+            ],
             harvest={
-                'domain': 'example.com',
-                'backend': 'dummy_backend',
-                'modified_at': another_date,
-                'created_at': another_date,
+                "domain": "example.com",
+                "backend": "dummy_backend",
+                "modified_at": another_date,
+                "created_at": another_date,
             },
         )
         DatasetFactory(resources=[ResourceFactory()])
@@ -44,37 +47,43 @@ class DatasetCSVAdapterTest:
         date_modified = date_created + timedelta(days=1)
         harvest_dataset = DatasetFactory(
             harvest={
-                'domain': 'example.com',
-                'backend': 'dummy_backend',
-                'modified_at': date_modified,
-                'created_at': date_created,
+                "domain": "example.com",
+                "backend": "dummy_backend",
+                "modified_at": date_modified,
+                "created_at": date_created,
             },
         )
-        resources_dataset = DatasetFactory(resources=[
-            ResourceFactory(metrics={
-                'views': 42,
-            }),
-            ResourceFactory(metrics={
-                'views': 1337,
-            }),
-            ResourceFactory(),
-        ])
+        resources_dataset = DatasetFactory(
+            resources=[
+                ResourceFactory(
+                    metrics={
+                        "views": 42,
+                    }
+                ),
+                ResourceFactory(
+                    metrics={
+                        "views": 1337,
+                    }
+                ),
+                ResourceFactory(),
+            ]
+        )
         adapter = DatasetCsvAdapter(Dataset.objects.all())
 
         # Build a dict (Dataset ID to dict of header name to value) from the CSV values and headers to simplify testing below.
         csv = {}
         for row in adapter.rows():
             values = dict(zip(adapter.header(), row))
-            csv[values['id']] = values
+            csv[values["id"]] = values
 
         harvest_dataset_values = csv[str(harvest_dataset.id)]
-        assert harvest_dataset_values['harvest.created_at'] == date_created.isoformat()
-        assert harvest_dataset_values['harvest.modified_at'] == date_modified.isoformat()
-        assert harvest_dataset_values['harvest.backend'] == 'dummy_backend'
-        assert harvest_dataset_values['harvest.domain'] == 'example.com'
-        assert harvest_dataset_values['resources_count'] == 0
-        assert harvest_dataset_values['downloads'] == 0
-        
+        assert harvest_dataset_values["harvest.created_at"] == date_created.isoformat()
+        assert harvest_dataset_values["harvest.modified_at"] == date_modified.isoformat()
+        assert harvest_dataset_values["harvest.backend"] == "dummy_backend"
+        assert harvest_dataset_values["harvest.domain"] == "example.com"
+        assert harvest_dataset_values["resources_count"] == 0
+        assert harvest_dataset_values["downloads"] == 0
+
         resources_dataset_values = csv[str(resources_dataset.id)]
-        assert resources_dataset_values['resources_count'] == 3
-        assert resources_dataset_values['downloads'] == 1337 + 42
+        assert resources_dataset_values["resources_count"] == 3
+        assert resources_dataset_values["downloads"] == 1337 + 42

udata/tests/dataset/test_dataset_actions.py

@@ -6,12 +6,11 @@ from udata.core.discussions.models import Discussion
 from udata.core.user.factories import UserFactory
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class DatasetActionsTest:
-
     def test_dataset_archive(self, app):
         user = UserFactory()
-        app.config['ARCHIVE_COMMENT_USER_ID'] = user.id
+        app.config["ARCHIVE_COMMENT_USER_ID"] = user.id
 
         dataset = DatasetFactory()
 

udata/tests/dataset/test_dataset_commands.py

@@ -1,17 +1,16 @@
-import pytest
-
 from tempfile import NamedTemporaryFile
 
+import pytest
+
 from udata.core.dataset.factories import DatasetFactory
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class DatasetCommandTest:
-
     def test_dataset_archive_one(self, cli):
         dataset = DatasetFactory()
 
-        cli('dataset', 'archive-one', str(dataset.id))
+        cli("dataset", "archive-one", str(dataset.id))
 
         dataset.reload()
         assert dataset.archived is not None
@@ -19,11 +18,11 @@ class DatasetCommandTest:
     def test_dataset_archive(self, cli):
         datasets = [DatasetFactory() for _ in range(2)]
 
-        with NamedTemporaryFile(mode='w', encoding='utf8') as temp:
-            temp.write('\n'.join((str(d.id) for d in datasets)))
+        with NamedTemporaryFile(mode="w", encoding="utf8") as temp:
+            temp.write("\n".join((str(d.id) for d in datasets)))
             temp.flush()
 
-            cli('dataset', 'archive', temp.name)
+            cli("dataset", "archive", temp.name)
 
         for dataset in datasets:
             dataset.reload()

udata/tests/dataset/test_dataset_events.py

@@ -1,75 +1,82 @@
-from flask import current_app
-import pytest
 from unittest.mock import patch
-from udata.core.dataset.models import Schema
 
+import pytest
+from flask import current_app
+from requests.compat import json as complexjson
+
+from udata.core.dataset.events import serialize_resource_for_event
+from udata.core.dataset.factories import DatasetFactory, ResourceFactory
+from udata.core.dataset.models import Schema
 from udata.models import Dataset
 from udata.tests.helpers import assert_emit
-from udata.core.dataset.events import serialize_resource_for_event
-from udata.core.dataset.factories import ResourceFactory, DatasetFactory
-from requests.compat import json as complexjson
 
-@pytest.mark.usefixtures('clean_db')
-@pytest.mark.usefixtures('enable_resource_event')
-class DatasetEventsTest:
 
-    @patch('requests.post')
+@pytest.mark.usefixtures("clean_db")
+@pytest.mark.usefixtures("enable_resource_event")
+class DatasetEventsTest:
+    @patch("requests.post")
     def test_publish_message_resource_created(self, mock_req):
         dataset = DatasetFactory()
         resource = ResourceFactory()
         expected_signals = (Dataset.on_resource_added,)
 
         expected_value = {
-            'resource_id': str(resource.id),
-            'dataset_id': str(dataset.id),
-            'document': serialize_resource_for_event(resource)
+            "resource_id": str(resource.id),
+            "dataset_id": str(dataset.id),
+            "document": serialize_resource_for_event(resource),
         }
 
         with assert_emit(*expected_signals):
             dataset.add_resource(resource)
 
-        mock_req.assert_called_with(f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/created/",
-                                    json=expected_value)
+        mock_req.assert_called_with(
+            f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/created/",
+            json=expected_value,
+        )
 
-    @patch('requests.post')
+    @patch("requests.post")
     def test_publish_message_resource_modified(self, mock_req):
         resource = ResourceFactory(schema=Schema(url="http://localhost/my-schema"))
         dataset = DatasetFactory(resources=[resource])
         expected_signals = (Dataset.on_resource_updated,)
 
-        resource.description = 'New description'
+        resource.description = "New description"
 
         expected_value = {
-            'resource_id': str(resource.id),
-            'dataset_id': str(dataset.id),
-            'document': serialize_resource_for_event(resource)
+            "resource_id": str(resource.id),
+            "dataset_id": str(dataset.id),
+            "document": serialize_resource_for_event(resource),
         }
 
         with assert_emit(*expected_signals):
             dataset.update_resource(resource)
 
-        mock_req.assert_called_with(f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/updated/",
-                                    json=expected_value)
-        
+        mock_req.assert_called_with(
+            f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/updated/",
+            json=expected_value,
+        )
+
         # Mocking requests call doesn't call the JSON encoder
         # so calling it manually here to prevent encoding errors.
         # (for example, encoding Embeds fails)
         complexjson.dumps(expected_value)
 
-    @patch('requests.post')
+    @patch("requests.post")
     def test_publish_message_resource_removed(self, mock_req):
         resource = ResourceFactory()
         dataset = DatasetFactory(resources=[resource])
         expected_signals = (Dataset.on_resource_removed,)
 
         expected_value = {
-            'resource_id': str(resource.id),
-            'dataset_id': str(dataset.id),
-            'document': None
+            "resource_id": str(resource.id),
+            "dataset_id": str(dataset.id),
+            "document": None,
         }
 
         with assert_emit(*expected_signals):
             dataset.remove_resource(resource)
 
-        mock_req.assert_called_with(f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/deleted/",
-                                    json=expected_value)
+        mock_req.assert_called_with(
+            f"{current_app.config['RESOURCES_ANALYSER_URI']}/api/resource/deleted/",
+            json=expected_value,
+        )