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

udata/tests/search/test_adapter.py

@@ -1,21 +1,24 @@
 import datetime
+from unittest.mock import patch
 
 import pytest
-
 from flask import current_app
 from flask_restx import inputs
 from flask_restx.reqparse import RequestParser
-from unittest.mock import patch
 
 from udata import search
+from udata.core.dataset.factories import (
+    DatasetFactory,
+    HiddenDatasetFactory,
+    ResourceFactory,
+)
 from udata.core.dataset.models import Schema
+from udata.core.dataset.search import DatasetSearch
 from udata.i18n import gettext as _
-from udata.utils import clean_string
-from udata.search import reindex, as_task_param
+from udata.search import as_task_param, reindex
 from udata.search.commands import index_model
-from udata.core.dataset.search import DatasetSearch
-from udata.core.dataset.factories import DatasetFactory, ResourceFactory, HiddenDatasetFactory
 from udata.tests.api import APITestCase
+from udata.utils import clean_string
 
 from . import FakeSearch
 
@@ -24,35 +27,30 @@ from . import FakeSearch
 #############################################################################
 
 RANGE_LABELS = {
-    'none': _('Never reused'),
-    'little': _('Little reused'),
-    'quite': _('Quite reused'),
-    'heavy': _('Heavily reused'),
+    "none": _("Never reused"),
+    "little": _("Little reused"),
+    "quite": _("Quite reused"),
+    "heavy": _("Heavily reused"),
 }
 
 
 class FakeSearchWithBool(FakeSearch):
-    filters = {
-        'boolean': search.BoolFilter()
-    }
+    filters = {"boolean": search.BoolFilter()}
 
 
 class FakeSearchWithCoverage(FakeSearch):
-    filters = {
-        'coverage': search.TemporalCoverageFilter()
-    }
+    filters = {"coverage": search.TemporalCoverageFilter()}
 
 
 #############################################################################
 #                                 Helpers                                   #
 #############################################################################
 
+
 def assertHasArgument(parser, name, _type, choices=None):
     __tracebackhide__ = True
-    candidates = [
-        arg for arg in parser.args if arg.name == name
-    ]
-    assert len(candidates) == 1, 'Should have strictly one argument'
+    candidates = [arg for arg in parser.args if arg.name == name]
+    assert len(candidates) == 1, "Should have strictly one argument"
     arg = candidates[0]
     assert arg.type == _type
     assert not arg.required
@@ -64,6 +62,7 @@ def assertHasArgument(parser, name, _type, choices=None):
 #                                  Tests                                    #
 #############################################################################
 
+
 class SearchAdaptorTest:
     def test_as_request_parser_filter(self):
         parser = FakeSearch.as_request_parser()
@@ -71,12 +70,12 @@ class SearchAdaptorTest:
 
         # query + tag and other filters + sorts + pagination
         assert len(parser.args) == 6
-        assertHasArgument(parser, 'q', str)
-        assertHasArgument(parser, 'sort', str)
-        assertHasArgument(parser, 'tag', clean_string)
-        assertHasArgument(parser, 'other', clean_string)
-        assertHasArgument(parser, 'page', int)
-        assertHasArgument(parser, 'page_size', int)
+        assertHasArgument(parser, "q", str)
+        assertHasArgument(parser, "sort", str)
+        assertHasArgument(parser, "tag", clean_string)
+        assertHasArgument(parser, "other", clean_string)
+        assertHasArgument(parser, "page", int)
+        assertHasArgument(parser, "page_size", int)
 
     def test_as_request_parser_bool_filter(self):
         parser = FakeSearchWithBool.as_request_parser()
@@ -84,102 +83,93 @@ class SearchAdaptorTest:
 
         # query + boolean filter + sorts + pagination
         assert len(parser.args) == 5
-        assertHasArgument(parser, 'q', str)
-        assertHasArgument(parser, 'sort', str)
-        assertHasArgument(parser, 'boolean', inputs.boolean)
-        assertHasArgument(parser, 'page', int)
-        assertHasArgument(parser, 'page_size', int)
+        assertHasArgument(parser, "q", str)
+        assertHasArgument(parser, "sort", str)
+        assertHasArgument(parser, "boolean", inputs.boolean)
+        assertHasArgument(parser, "page", int)
+        assertHasArgument(parser, "page_size", int)
 
     def test_as_request_parser_temporal_coverage_facet(self):
         parser = FakeSearchWithCoverage.as_request_parser()
-        filter = FakeSearchWithCoverage.filters['coverage']
+        filter = FakeSearchWithCoverage.filters["coverage"]
         assert isinstance(parser, RequestParser)
 
         # query + range facet + sorts + pagination
         assert len(parser.args) == 5
-        assertHasArgument(parser, 'q', str)
-        assertHasArgument(parser, 'sort', str)
-        assertHasArgument(parser, 'coverage', filter.validate_parameter)
-        assertHasArgument(parser, 'page', int)
-        assertHasArgument(parser, 'page_size', int)
+        assertHasArgument(parser, "q", str)
+        assertHasArgument(parser, "sort", str)
+        assertHasArgument(parser, "coverage", filter.validate_parameter)
+        assertHasArgument(parser, "page", int)
+        assertHasArgument(parser, "page_size", int)
 
 
 @pytest.mark.options(SEARCH_SERVICE_API_URL="smtg/")
 class IndexingLifecycleTest(APITestCase):
-
-    @patch('requests.delete')
+    @patch("requests.delete")
     def test_producer_should_send_a_message_without_payload_if_not_indexable(self, mock_req):
-        fake_data = HiddenDatasetFactory(id='61fd30cb29ea95c7bc0e1211')
+        fake_data = HiddenDatasetFactory(id="61fd30cb29ea95c7bc0e1211")
 
         reindex.run(*as_task_param(fake_data))
 
-        search_service_url = current_app.config['SEARCH_SERVICE_API_URL']
-        url = f'{search_service_url}{DatasetSearch.search_url}{str(fake_data.id)}/unindex'
+        search_service_url = current_app.config["SEARCH_SERVICE_API_URL"]
+        url = f"{search_service_url}{DatasetSearch.search_url}{str(fake_data.id)}/unindex"
         mock_req.assert_called_with(url)
 
-    @patch('requests.post')
+    @patch("requests.post")
     def test_producer_should_send_a_message_with_payload_if_indexable(self, mock_req):
         resource = ResourceFactory(schema=Schema(url="http://localhost/my-schema"))
-        fake_data = DatasetFactory(id='61fd30cb29ea95c7bc0e1211', resources=[resource])
+        fake_data = DatasetFactory(id="61fd30cb29ea95c7bc0e1211", resources=[resource])
 
         reindex.run(*as_task_param(fake_data))
 
-        expected_value = {
-            'document': DatasetSearch.serialize(fake_data)
-        }
+        expected_value = {"document": DatasetSearch.serialize(fake_data)}
         url = f"{current_app.config['SEARCH_SERVICE_API_URL']}{DatasetSearch.search_url}index"
         mock_req.assert_called_with(url, json=expected_value)
 
-    @patch('requests.Session.post')
+    @patch("requests.Session.post")
     def test_index_model(self, mock_req):
-        fake_data = DatasetFactory(id='61fd30cb29ea95c7bc0e1211')
+        fake_data = DatasetFactory(id="61fd30cb29ea95c7bc0e1211")
 
         index_model(DatasetSearch, start=None, reindex=False, from_datetime=None)
 
-        expected_value = {
-            'document': DatasetSearch.serialize(fake_data),
-            'index': 'dataset'
-        }
+        expected_value = {"document": DatasetSearch.serialize(fake_data), "index": "dataset"}
         url = f"{current_app.config['SEARCH_SERVICE_API_URL']}/datasets/index"
         mock_req.assert_called_with(url, json=expected_value)
 
-    @patch('requests.post')
-    @patch('requests.Session.post')
+    @patch("requests.post")
+    @patch("requests.Session.post")
     def test_reindex_model(self, mock_session, mock_req):
-        fake_data = DatasetFactory(id='61fd30cb29ea95c7bc0e1211')
+        fake_data = DatasetFactory(id="61fd30cb29ea95c7bc0e1211")
 
         index_model(DatasetSearch, start=datetime.datetime(2022, 2, 20, 20, 2), reindex=True)
 
         # Create index
-        expected_value = {
-            'index': 'dataset-2022-02-20-20-02'
-        }
+        expected_value = {"index": "dataset-2022-02-20-20-02"}
         url = f"{current_app.config['SEARCH_SERVICE_API_URL']}/create-index"
         mock_req.assert_called_with(url, json=expected_value)
 
         # Index document
         expected_value = {
-            'document': DatasetSearch.serialize(fake_data),
-            'index': 'dataset-2022-02-20-20-02'
+            "document": DatasetSearch.serialize(fake_data),
+            "index": "dataset-2022-02-20-20-02",
         }
         url = f"{current_app.config['SEARCH_SERVICE_API_URL']}/datasets/index"
         mock_session.assert_called_with(url, json=expected_value)
 
-    @patch('requests.Session.post')
+    @patch("requests.Session.post")
     def test_index_model_from_datetime(self, mock_req):
-        DatasetFactory(id='61fd30cb29ea95c7bc0e1211',
-                       last_modified_internal=datetime.datetime(2020, 1, 1))
-        fake_data = DatasetFactory(id='61fd30cb29ea95c7bc0e1212',
-                                   last_modified_internal=datetime.datetime(2022, 1, 1))
+        DatasetFactory(
+            id="61fd30cb29ea95c7bc0e1211", last_modified_internal=datetime.datetime(2020, 1, 1)
+        )
+        fake_data = DatasetFactory(
+            id="61fd30cb29ea95c7bc0e1212", last_modified_internal=datetime.datetime(2022, 1, 1)
+        )
 
         index_model(DatasetSearch, start=None, from_datetime=datetime.datetime(2023, 1, 1))
         mock_req.assert_not_called()
 
         index_model(DatasetSearch, start=None, from_datetime=datetime.datetime(2021, 1, 1))
 
-        expected_value = {
-            'document': DatasetSearch.serialize(fake_data),
-            'index': 'dataset'
-        }
+        expected_value = {"document": DatasetSearch.serialize(fake_data), "index": "dataset"}
         url = f"{current_app.config['SEARCH_SERVICE_API_URL']}/datasets/index"
         mock_req.assert_called_with(url, json=expected_value)

udata/tests/search/test_query.py

@@ -1,39 +1,39 @@
+from udata.search.query import DEFAULT_PAGE_SIZE, SearchQuery
 from udata.tests.api import APITestCase
-from udata.search.query import SearchQuery, DEFAULT_PAGE_SIZE
 
 
 class QueryTest(APITestCase):
     def test_search_query_with_params(self):
         query = {
-            'organization': '534fff81a3a7292c64a77e5c',
-            'q': 'insee',
-            'sort': '-created',
-            'page': 1,
-            'page_size': 20
+            "organization": "534fff81a3a7292c64a77e5c",
+            "q": "insee",
+            "sort": "-created",
+            "page": 1,
+            "page_size": 20,
         }
         search_query = SearchQuery(params=query)
         assert search_query.page == 1
         assert search_query.page_size == 20
-        assert search_query._query == 'insee'
-        assert search_query.sort == '-created'
-        assert search_query._filters['organization'] == '534fff81a3a7292c64a77e5c'
+        assert search_query._query == "insee"
+        assert search_query.sort == "-created"
+        assert search_query._filters["organization"] == "534fff81a3a7292c64a77e5c"
 
     def test_search_query_without_params(self):
         search_query = SearchQuery(params={})
         assert search_query.page == 1
         assert search_query.page_size == DEFAULT_PAGE_SIZE
-        assert search_query._query == ''
+        assert search_query._query == ""
         assert search_query.sort is None
         assert search_query._filters == {}
 
     def test_search_query_to_url(self):
         query = {
-            'organization': '534fff81a3a7292c64a77e5c',
-            'q': 'insee',
-            'sort': '-created',
-            'page': 1,
-            'page_size': 20
+            "organization": "534fff81a3a7292c64a77e5c",
+            "q": "insee",
+            "sort": "-created",
+            "page": 1,
+            "page_size": 20,
         }
         search_query = SearchQuery(params=query)
         url = search_query.to_url()
-        assert 'organization=534fff81a3a7292c64a77e5c&q=insee&sort=-created&page=1' in url
+        assert "organization=534fff81a3a7292c64a77e5c&q=insee&sort=-created&page=1" in url

udata/tests/search/test_results.py

@@ -1,8 +1,8 @@
-from udata.tests.api import APITestCase
-from udata.search.result import SearchResult
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.dataset.search import DatasetSearch
 from udata.models import Dataset
+from udata.search.result import SearchResult
+from udata.tests.api import APITestCase
 
 
 class ResultTest(APITestCase):
@@ -21,9 +21,11 @@ class ResultTest(APITestCase):
             "previous_page": None,
             "page_size": 20,
             "total_pages": 1,
-            "total": 3
+            "total": 3,
         }
-        search_results = SearchResult(query=search_query, result=service_result.pop('data'), **service_result)
+        search_results = SearchResult(
+            query=search_query, result=service_result.pop("data"), **service_result
+        )
 
         assert len(search_results.get_objects()) == 3
 
@@ -45,9 +47,11 @@ class ResultTest(APITestCase):
             "previous_page": None,
             "page_size": 20,
             "total_pages": 1,
-            "total": 3
+            "total": 3,
         }
-        search_results = SearchResult(query=search_query, result=service_result.pop('data'), **service_result)
+        search_results = SearchResult(
+            query=search_query, result=service_result.pop("data"), **service_result
+        )
 
         to_delete_random_dataset.delete()
         assert len(search_results.get_objects()) == 3
@@ -56,4 +60,3 @@ class ResultTest(APITestCase):
         objects = search_results.objects
         for o in objects:
             assert isinstance(o, Dataset)
-

udata/tests/site/test_site_api.py

@@ -1,13 +1,10 @@
-
 from flask import url_for
 
-from udata.core.site.models import Site
-from udata.core.site.models import current_site
-from udata.core.site.factories import SiteFactory
 from udata.core.dataset.factories import DatasetFactory
 from udata.core.reuse.factories import VisibleReuseFactory
+from udata.core.site.factories import SiteFactory
+from udata.core.site.models import Site, current_site
 from udata.core.user.factories import AdminFactory
-
 from udata.tests.api import APITestCase
 
 
@@ -15,31 +12,29 @@ class SiteAPITest(APITestCase):
     modules = []
 
     def test_get_site(self):
-        response = self.get(url_for('api.site'))
+        response = self.get(url_for("api.site"))
         self.assert200(response)
 
     def test_get_home_datasets(self):
         site = SiteFactory.create(
-            id=self.app.config['SITE_ID'],
-            settings__home_datasets=DatasetFactory.create_batch(3)
+            id=self.app.config["SITE_ID"], settings__home_datasets=DatasetFactory.create_batch(3)
         )
         current_site.reload()
 
         self.login(AdminFactory())
-        response = self.get(url_for('api.home_datasets'))
+        response = self.get(url_for("api.home_datasets"))
         self.assert200(response)
 
         self.assertEqual(len(response.json), len(site.settings.home_datasets))
 
     def test_get_home_reuses(self):
         site = SiteFactory.create(
-            id=self.app.config['SITE_ID'],
-            settings__home_reuses=VisibleReuseFactory.create_batch(3)
+            id=self.app.config["SITE_ID"], settings__home_reuses=VisibleReuseFactory.create_batch(3)
         )
         current_site.reload()
 
         self.login(AdminFactory())
-        response = self.get(url_for('api.home_reuses'))
+        response = self.get(url_for("api.home_reuses"))
         self.assert200(response)
 
         self.assertEqual(len(response.json), len(site.settings.home_reuses))
@@ -48,12 +43,12 @@ class SiteAPITest(APITestCase):
         ids = [d.id for d in DatasetFactory.create_batch(3)]
 
         self.login(AdminFactory())
-        response = self.put(url_for('api.home_datasets'), ids)
+        response = self.put(url_for("api.home_datasets"), ids)
 
         self.assert200(response)
         self.assertEqual(len(response.json), len(ids))
 
-        site = Site.objects.get(id=self.app.config['SITE_ID'])
+        site = Site.objects.get(id=self.app.config["SITE_ID"])
 
         self.assertEqual([d.id for d in site.settings.home_datasets], ids)
 
@@ -61,11 +56,11 @@ class SiteAPITest(APITestCase):
         ids = [r.id for r in VisibleReuseFactory.create_batch(3)]
 
         self.login(AdminFactory())
-        response = self.put(url_for('api.home_reuses'), ids)
+        response = self.put(url_for("api.home_reuses"), ids)
 
         self.assert200(response)
         self.assertEqual(len(response.json), len(ids))
 
-        site = Site.objects.get(id=self.app.config['SITE_ID'])
+        site = Site.objects.get(id=self.app.config["SITE_ID"])
 
         self.assertEqual([r.id for r in site.settings.home_reuses], ids)

udata/tests/site/test_site_metrics.py

@@ -1,67 +1,59 @@
 import pytest
 
-from udata.core.dataset.factories import DatasetFactory, HiddenDatasetFactory, OrganizationFactory
+from udata.core.dataset.factories import (
+    DatasetFactory,
+    HiddenDatasetFactory,
+    OrganizationFactory,
+)
+from udata.core.organization.constants import PUBLIC_SERVICE
 from udata.core.reuse.factories import VisibleReuseFactory
-from udata.harvest.tests.factories import HarvestSourceFactory
 from udata.core.site.factories import SiteFactory
+from udata.harvest.tests.factories import HarvestSourceFactory
 from udata.models import Badge
-from udata.core.organization.constants import PUBLIC_SERVICE
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class SiteMetricTest:
     def test_orga_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
         OrganizationFactory.create_batch(3)
 
         site.count_org()
 
-        assert site.get_metrics()['organizations'] == 3
+        assert site.get_metrics()["organizations"] == 3
 
     def test_reuse_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
         VisibleReuseFactory.create_batch(4)
 
         site.count_reuses()
 
-        assert site.get_metrics()['reuses'] == 4
+        assert site.get_metrics()["reuses"] == 4
 
     def test_dataset_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
         DatasetFactory.create_batch(2)
         HiddenDatasetFactory.create_batch(3)
 
         site.count_datasets()
 
-        assert site.get_metrics()['datasets'] == 2
+        assert site.get_metrics()["datasets"] == 2
 
     def test_resources_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
 
         DatasetFactory.create_batch(3, nb_resources=3)
 
         site.count_datasets()
         site.count_resources()
 
-        assert site.get_metrics()['resources'] == 9
+        assert site.get_metrics()["resources"] == 9
 
     def test_badges_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
 
         ps_badge = Badge(kind=PUBLIC_SERVICE)
-        public_services = [
-            OrganizationFactory(badges=[ps_badge]) for _ in range(2)
-        ]
+        public_services = [OrganizationFactory(badges=[ps_badge]) for _ in range(2)]
         for _ in range(3):
             OrganizationFactory()
 
@@ -70,11 +62,9 @@ class SiteMetricTest:
         assert site.get_metrics()[PUBLIC_SERVICE] == len(public_services)
 
     def test_harvesters_metric(self, app):
-        site = SiteFactory.create(
-            id=app.config['SITE_ID']
-        )
+        site = SiteFactory.create(id=app.config["SITE_ID"])
         sources = [HarvestSourceFactory() for i in range(10)]
 
         site.count_harvesters()
 
-        assert site.get_metrics()['harvesters'] == len(sources)
+        assert site.get_metrics()["harvesters"] == len(sources)

udata/tests/site/test_site_model.py

@@ -1,15 +1,14 @@
 from datetime import datetime
 
 from udata.core.dataset.factories import DatasetFactory
-from udata.core.site.models import current_site
 from udata.core.reuse.factories import ReuseFactory
-
-from udata.tests import TestCase, DBTestMixin
+from udata.core.site.models import current_site
+from udata.tests import DBTestMixin, TestCase
 
 
 class SiteModelTest(DBTestMixin, TestCase):
     def test_delete_home_dataset(self):
-        '''Should pull home datasets on deletion'''
+        """Should pull home datasets on deletion"""
         current_site.settings.home_datasets = DatasetFactory.create_batch(3)
         current_site.save()
 
@@ -23,7 +22,7 @@ class SiteModelTest(DBTestMixin, TestCase):
         self.assertNotIn(dataset.id, home_datasets)
 
     def test_delete_home_reuse(self):
-        '''Should pull home reuses on deletion'''
+        """Should pull home reuses on deletion"""
         current_site.settings.home_reuses = ReuseFactory.create_batch(3)
         current_site.save()