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

udata/tests/dataset/test_dataset_tasks.py

@@ -1,47 +1,47 @@
-from udata.core.user.factories import UserFactory
 import pytest
 
-from udata.models import Dataset, Topic, CommunityResource, Transfer
 from udata.core.dataset import tasks
-from udata.core.dataset.factories import DatasetFactory, CommunityResourceFactory
+
 # Those imports seem mandatory for the csv adapters to be registered.
 # This might be because of the decorator mechanism.
 from udata.core.dataset.csv import DatasetCsvAdapter, ResourcesCsvAdapter  # noqa
+from udata.core.dataset.factories import CommunityResourceFactory, DatasetFactory
 from udata.core.organization.csv import OrganizationCsvAdapter  # noqa
 from udata.core.reuse.csv import ReuseCsvAdapter  # noqa
 from udata.core.tags.csv import TagCsvAdapter  # noqa
+from udata.core.user.factories import UserFactory
 from udata.harvest.csv import HarvestSourceCsvAdapter  # noqa
+from udata.models import CommunityResource, Dataset, Topic, Transfer
 
-
-pytestmark = pytest.mark.usefixtures('clean_db')
+pytestmark = pytest.mark.usefixtures("clean_db")
 
 
 def test_purge_datasets():
     datasets = [
-        Dataset.objects.create(title='delete me', deleted='2016-01-01'),
-        Dataset.objects.create(title='keep me'),
+        Dataset.objects.create(title="delete me", deleted="2016-01-01"),
+        Dataset.objects.create(title="keep me"),
     ]
 
-    topic = Topic.objects.create(name='test topic', datasets=datasets)
+    topic = Topic.objects.create(name="test topic", datasets=datasets)
 
     user = UserFactory()
     transfer = Transfer.objects.create(
         owner=user,
         recipient=user,
         subject=datasets[0],
-        comment='comment',
+        comment="comment",
     )
 
     tasks.purge_datasets()
 
     assert Transfer.objects.filter(id=transfer.id).count() == 0
 
-    topic = Topic.objects(name='test topic').first()
+    topic = Topic.objects(name="test topic").first()
     assert topic.datasets[0] == datasets[1]
 
 
 def test_purge_datasets_community():
-    dataset = Dataset.objects.create(title='delete me', deleted='2016-01-01')
+    dataset = Dataset.objects.create(title="delete me", deleted="2016-01-01")
     community_resource1 = CommunityResourceFactory()
     community_resource1.dataset = dataset
     community_resource1.save()
@@ -50,15 +50,15 @@ def test_purge_datasets_community():
     assert CommunityResource.objects.count() == 0
 
 
-@pytest.mark.usefixtures('instance_path')
+@pytest.mark.usefixtures("instance_path")
 def test_export_csv(app):
     dataset = DatasetFactory()
-    app.config['EXPORT_CSV_DATASET_ID'] = dataset.id
-    models = app.config['EXPORT_CSV_MODELS']
+    app.config["EXPORT_CSV_DATASET_ID"] = dataset.id
+    models = app.config["EXPORT_CSV_MODELS"]
     tasks.export_csv()
     dataset = Dataset.objects.get(id=dataset.id)
     assert len(dataset.resources) == len(models)
-    extras = [r.extras.get('csv-export:model') for r in dataset.resources]
+    extras = [r.extras.get("csv-export:model") for r in dataset.resources]
     for model in models:
         assert model in extras
     fs_filenames = [r.fs_filename for r in dataset.resources if r.url.endswith(r.fs_filename)]

udata/tests/dataset/test_resource_preview.py

@@ -1,14 +1,12 @@
 import pytest
 
-from udata.core.dataset.preview import PreviewPlugin, PreviewWarning
 from udata.core.dataset.factories import DatasetFactory
+from udata.core.dataset.preview import PreviewPlugin, PreviewWarning
 
-pytestmark = [
-    pytest.mark.usefixtures('clean_db')
-]
+pytestmark = [pytest.mark.usefixtures("clean_db")]
 
-PREVIEW_URL = 'http://preview'
-FALLBACK_PREVIEW_URL = 'http://preview/default'
+PREVIEW_URL = "http://preview"
+FALLBACK_PREVIEW_URL = "http://preview/default"
 
 
 class AlwaysPreview(PreviewPlugin):
@@ -32,7 +30,7 @@ class PreviewFromDataset(PreviewPlugin):
         return True
 
     def preview_url(self, resource):
-        return resource.dataset.extras['preview']
+        return resource.dataset.extras["preview"]
 
 
 class FallbackPreview(PreviewPlugin):
@@ -58,12 +56,12 @@ class NotAValidPlugin(object):
 class ResourcePreviewTest:
     @pytest.fixture(autouse=True)
     def patch_entrypoint(self, request, mocker, app):
-        marker = request.node.get_closest_marker('preview')
+        marker = request.node.get_closest_marker("preview")
         plugins = marker.args[0] if marker else []
-        m = mocker.patch('udata.entrypoints.get_enabled')
+        m = mocker.patch("udata.entrypoints.get_enabled")
         m.return_value.values.return_value = plugins  # Keep order
         yield
-        m.assert_called_with('udata.preview', app)
+        m.assert_called_with("udata.preview", app)
 
     def test_preview_is_none_by_default(self):
         dataset = DatasetFactory(visible=True)
@@ -90,8 +88,7 @@ class ResourcePreviewTest:
 
     @pytest.mark.preview([PreviewFromDataset])
     def test_can_access_dataset_metadata(self):
-        dataset = DatasetFactory(visible=True,
-                                 extras={'preview': PREVIEW_URL})
+        dataset = DatasetFactory(visible=True, extras={"preview": PREVIEW_URL})
         resource = dataset.resources[0]
         assert resource.preview_url == PREVIEW_URL
 
@@ -116,7 +113,7 @@ class ResourcePreviewTest:
 
     @pytest.mark.preview([NotAValidPlugin])
     def test_warn_but_ignore_invalid_plugins(self):
-        expected_msg = 'NotAValidPlugin is not a valid preview plugin'
+        expected_msg = "NotAValidPlugin is not a valid preview plugin"
         with pytest.warns(PreviewWarning, match=expected_msg):
             dataset = DatasetFactory(visible=True)
             resource = dataset.resources[0]

udata/tests/features/territories/__init__.py

@@ -4,27 +4,23 @@ from udata.settings import Testing
 
 def create_geozones_fixtures():
     paca = GeoZoneFactory(
-        id='fr:region:93', level='fr:region',
-        name='Provence Alpes Côtes dAzur', code='93')
+        id="fr:region:93", level="fr:region", name="Provence Alpes Côtes dAzur", code="93"
+    )
     bdr = GeoZoneFactory(
-        id='fr:departement:13', level='fr:departement',
-        name='Bouches-du-Rhône', code='13')
-    arles = GeoZoneFactory(
-        id='fr:commune:13004', level='fr:commune',
-        name='Arles', code='13004')
+        id="fr:departement:13", level="fr:departement", name="Bouches-du-Rhône", code="13"
+    )
+    arles = GeoZoneFactory(id="fr:commune:13004", level="fr:commune", name="Arles", code="13004")
     return paca, bdr, arles
 
 
 def create_old_new_regions_fixtures():
-    lr = GeoZoneFactory(
-        id='fr:region:91', level='fr:region',
-        name='Languedoc-Rousillon', code='91')
+    lr = GeoZoneFactory(id="fr:region:91", level="fr:region", name="Languedoc-Rousillon", code="91")
     occitanie = GeoZoneFactory(
-        id='fr:region:76', level='fr:region',
-        name='Languedoc-Rousillon et Midi-Pyrénées', code='76')
+        id="fr:region:76", level="fr:region", name="Languedoc-Rousillon et Midi-Pyrénées", code="76"
+    )
     return lr, occitanie
 
 
 class TerritoriesSettings(Testing):
     ACTIVATE_TERRITORIES = True
-    HANDLED_LEVELS = ('fr:commune', 'fr:departement', 'fr:region', 'country')
+    HANDLED_LEVELS = ("fr:commune", "fr:departement", "fr:region", "country")

udata/tests/features/territories/test_territories_api.py

@@ -3,8 +3,9 @@ from flask import url_for
 from udata.core.spatial.factories import GeoZoneFactory
 from udata.tests.api import APITestCase
 from udata.tests.features.territories import (
-    create_geozones_fixtures, create_old_new_regions_fixtures,
-    TerritoriesSettings
+    TerritoriesSettings,
+    create_geozones_fixtures,
+    create_old_new_regions_fixtures,
 )
 
 
@@ -16,189 +17,168 @@ class TerritoriesAPITest(APITestCase):
         self.paca, self.bdr, self.arles = create_geozones_fixtures()
 
     def test_suggest_no_parameter(self):
-        response = self.get(url_for('api.suggest_territory'))
+        response = self.get(url_for("api.suggest_territory"))
         self.assert400(response)
 
     def test_suggest_empty(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'tes'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "tes"})
         self.assert200(response)
         self.assertEqual(response.json, [])
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'test'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "test"})
         self.assert200(response)
         self.assertEqual(response.json, [])
 
     def test_suggest_town(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'arle'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "arle"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['title'], self.arles.name)
-        self.assertEqual(result['id'], self.arles.id)
-        self.assertIn('page', result)
+        self.assertEqual(result["title"], self.arles.name)
+        self.assertEqual(result["id"], self.arles.id)
+        self.assertIn("page", result)
 
     def test_suggest_town_five_letters(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'arles'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "arles"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['title'], self.arles.name)
-        self.assertEqual(result['id'], self.arles.id)
-        self.assertIn('page', result)
+        self.assertEqual(result["title"], self.arles.name)
+        self.assertEqual(result["id"], self.arles.id)
+        self.assertIn("page", result)
 
     def test_suggest_town_by_insee_code(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': '13004'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "13004"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['id'], self.arles.id)
-        self.assertEqual(result['title'], self.arles.name)
+        self.assertEqual(result["id"], self.arles.id)
+        self.assertEqual(result["title"], self.arles.name)
 
     def test_suggest_towns(self):
         arles_sur_tech = GeoZoneFactory(
-            id='fr:commune:66009', level='fr:commune',
-            name='Arles-sur-Tech', code='66009')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'arles'})
+            id="fr:commune:66009", level="fr:commune", name="Arles-sur-Tech", code="66009"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "arles"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 2)
         # Arles must be first given the population.
-        self.assertEqual(results[0]['id'], self.arles.id)
-        self.assertEqual(results[1]['id'], arles_sur_tech.id)
+        self.assertEqual(results[0]["id"], self.arles.id)
+        self.assertEqual(results[1]["id"], arles_sur_tech.id)
 
     def test_suggest_county(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'bouche'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "bouche"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['title'], self.bdr.name)
-        self.assertEqual(result['id'], self.bdr.id)
-        self.assertIn('page', result)
+        self.assertEqual(result["title"], self.bdr.name)
+        self.assertEqual(result["id"], self.bdr.id)
+        self.assertIn("page", result)
 
     def test_suggest_region(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'prov'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "prov"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['title'], self.paca.name)
-        self.assertEqual(result['id'], self.paca.id)
-        self.assertIn('page', result)
+        self.assertEqual(result["title"], self.paca.name)
+        self.assertEqual(result["id"], self.paca.id)
+        self.assertIn("page", result)
 
     def test_suggest_old_new_region(self):
         lr, occitanie = create_old_new_regions_fixtures()
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'langue'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "langue"})
         self.assert200(response)
         self.assertEqual(len(response.json), 2)
         result = response.json[1]
-        self.assertEqual(result['title'], occitanie.name)
-        self.assertEqual(result['id'], occitanie.id)
+        self.assertEqual(result["title"], occitanie.name)
+        self.assertEqual(result["id"], occitanie.id)
         result = response.json[0]
-        self.assertEqual(result['title'], lr.name)
-        self.assertEqual(result['id'], lr.id)
+        self.assertEqual(result["title"], lr.name)
+        self.assertEqual(result["id"], lr.id)
 
     def test_suggest_county_by_id(self):
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': '13'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "13"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['id'], self.bdr.id)
-        self.assertEqual(result['title'], self.bdr.name)
+        self.assertEqual(result["id"], self.bdr.id)
+        self.assertEqual(result["title"], self.bdr.name)
 
     def test_suggest_town_and_county(self):
         bouchet = GeoZoneFactory(
-            id='fr:commune:26054', level='fr:commune',
-            name='Bouchet', code='26054')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'bouche'})
+            id="fr:commune:26054", level="fr:commune", name="Bouchet", code="26054"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "bouche"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 2)
         # BDR must be first given the population.
-        self.assertEqual(results[0]['id'], self.bdr.id)
-        self.assertEqual(results[1]['id'], bouchet.id)
+        self.assertEqual(results[0]["id"], self.bdr.id)
+        self.assertEqual(results[1]["id"], bouchet.id)
 
     def test_suggest_drom_com(self):
         guyane = GeoZoneFactory(
-            id='fr:departement:973', level='fr:departement',
-            name='Guyane', code='973')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'guya'})
+            id="fr:departement:973", level="fr:departement", name="Guyane", code="973"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "guya"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]['id'], guyane.id)
+        self.assertEqual(results[0]["id"], guyane.id)
 
     def test_suggest_drom_com_by_code(self):
         guyane = GeoZoneFactory(
-            id='fr:departement:973', level='fr:departement',
-            name='Guyane', code='973')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': '973'})
+            id="fr:departement:973", level="fr:departement", name="Guyane", code="973"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "973"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]['id'], guyane.id)
+        self.assertEqual(results[0]["id"], guyane.id)
 
     def test_suggest_corsica(self):
         bastia = GeoZoneFactory(
-            id='fr:commune:2b033', level='fr:commune',
-            name='Bastia', code='2b033')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'basti'})
+            id="fr:commune:2b033", level="fr:commune", name="Bastia", code="2b033"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "basti"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]['id'], bastia.id)
+        self.assertEqual(results[0]["id"], bastia.id)
 
     def test_suggest_corsica_by_code(self):
         bastia = GeoZoneFactory(
-            id='fr:commune:2b033', level='fr:commune',
-            name='Bastia', code='2b033')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': '2b033'})
+            id="fr:commune:2b033", level="fr:commune", name="Bastia", code="2b033"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "2b033"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]['id'], bastia.id)
+        self.assertEqual(results[0]["id"], bastia.id)
 
     def test_suggest_corsica_by_county_code(self):
         haute_corse = GeoZoneFactory(
-            id='fr:departement:2b', level='fr:departement',
-            name='Haute-Corse', code='2b')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': '2b'})
+            id="fr:departement:2b", level="fr:departement", name="Haute-Corse", code="2b"
+        )
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "2b"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 1)
-        self.assertEqual(results[0]['id'], haute_corse.id)
+        self.assertEqual(results[0]["id"], haute_corse.id)
 
     def test_not_suggest_country(self):
-        GeoZoneFactory(
-            id='country:fr', level='country', name='France')
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'fra'})
+        GeoZoneFactory(id="country:fr", level="country", name="France")
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "fra"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'fran'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "fran"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
-        response = self.get(
-            url_for('api.suggest_territory'), qs={'q': 'franc'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "franc"})
         self.assert200(response)
         results = response.json
         self.assertEqual(len(results), 0)
 
     def test_suggest_unicode(self):
-        response = self.get(url_for('api.suggest_territory'),
-                                    qs={'q': 'Bouches-du-Rhône'})
+        response = self.get(url_for("api.suggest_territory"), qs={"q": "Bouches-du-Rhône"})
         self.assert200(response)
         result = response.json[0]
-        self.assertEqual(result['title'], self.bdr.name)
-        self.assertEqual(result['id'], self.bdr.id)
-        self.assertIn('page', result)
+        self.assertEqual(result["title"], self.bdr.name)
+        self.assertEqual(result["id"], self.bdr.id)
+        self.assertIn("page", result)

udata/tests/forms/test_basic_fields.py

@@ -38,7 +38,7 @@ class UrlFieldTest(TestCase):
 
         fake = Fake()
         url = faker.url()
-        form = FakeForm(MultiDict({'url': url}))
+        form = FakeForm(MultiDict({"url": url}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -52,7 +52,7 @@ class UrlFieldTest(TestCase):
 
         fake = Fake()
         url = faker.url()
-        form = FakeForm(MultiDict({'url': url + '   '}))
+        form = FakeForm(MultiDict({"url": url + "   "}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -64,18 +64,18 @@ class UrlFieldTest(TestCase):
     def test_with_invalid_url(self):
         Fake, FakeForm = self.factory()
 
-        form = FakeForm(MultiDict({'url': 'this-is-not-an-url'}))
+        form = FakeForm(MultiDict({"url": "this-is-not-an-url"}))
 
         form.validate()
-        self.assertIn('url', form.errors)
-        self.assertEqual(len(form.errors['url']), 1)
+        self.assertIn("url", form.errors)
+        self.assertEqual(len(form.errors["url"]), 1)
 
     def test_with_unicode_url(self):
         Fake, FakeForm = self.factory()
 
         fake = Fake()
-        url = 'https://www.somewhère.com/with/accënts/'
-        form = FakeForm(MultiDict({'url': url}))
+        url = "https://www.somewhère.com/with/accënts/"
+        form = FakeForm(MultiDict({"url": url}))
 
         form.validate()
         self.assertEqual(form.errors, {})