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

udata/tests/plugin.py

@@ -1,14 +1,13 @@
-import pytest
 import shlex
-
 from contextlib import contextmanager
 from urllib.parse import urlparse
 
-from flask import json, template_rendered, url_for, current_app
+import pytest
+from flask import current_app, json, template_rendered, url_for
 from flask.testing import FlaskClient
+from flask_principal import Identity, identity_changed
 from lxml import etree
 from werkzeug.urls import url_encode
-from flask_principal import Identity, identity_changed
 
 from udata import settings
 from udata.app import create_app
@@ -20,10 +19,10 @@ from .helpers import assert200, assert_command_ok
 
 class TestClient(FlaskClient):
     def _build_url(self, url, kwargs):
-        if 'qs' not in kwargs:
+        if "qs" not in kwargs:
             return url
-        qs = kwargs.pop('qs')
-        return '?'.join([url, url_encode(qs)])
+        qs = kwargs.pop("qs")
+        return "?".join([url, url_encode(qs)])
 
     def get(self, url, **kwargs):
         url = self._build_url(url, kwargs)
@@ -46,18 +45,18 @@ class TestClient(FlaskClient):
         with self.session_transaction() as session:
             # Since flask-security-too 4.0.0, the user.fs_uniquifier is used instead of user.id for auth
             user_id = getattr(user, current_app.login_manager.id_attribute)()
-            session['user_id'] = user_id
-            session['_fresh'] = True
-            session['_id'] = current_app.login_manager._session_identifier_generator()
+            session["user_id"] = user_id
+            session["_fresh"] = True
+            session["_id"] = current_app.login_manager._session_identifier_generator()
             current_app.login_manager._update_request_context_with_user(user)
             identity_changed.send(current_app._get_current_object(), identity=Identity(user.id))
         return user
 
     def logout(self):
         with self.session_transaction() as session:
-            del session['user_id']
-            del session['_fresh']
-            del session['_id']
+            del session["user_id"]
+            del session["_fresh"]
+            del session["_id"]
 
 
 @pytest.fixture
@@ -70,57 +69,58 @@ def app(request):
 
 @pytest.fixture(autouse=True)
 def _load_frontend(request, _configure_application):
-    '''
+    """
     Use `pytest.mark.frontend` to specify that frontend/api should be loaded
     Pass an optionnal list of modules as parameter to restrict loaded modules.
 
     Handle backward compatibility with Class.modules attribute too
-    '''
-    if 'app' not in request.fixturenames:
+    """
+    if "app" not in request.fixturenames:
         return
 
-    app = request.getfixturevalue('app')
-    marker = request.node.get_closest_marker('frontend')
+    app = request.getfixturevalue("app")
+    marker = request.node.get_closest_marker("frontend")
     modules = set(marker.args[0] if marker and marker.args else [])
-    if getattr(request.cls, 'modules', None):
+    if getattr(request.cls, "modules", None):
         modules |= set(request.cls.modules)
 
-    if marker or hasattr(request.cls, 'modules'):
-        from udata import frontend, api
+    if marker or hasattr(request.cls, "modules"):
+        from udata import api, frontend
+
         api.init_app(app)
         frontend.init_app(app, modules)
 
 
 @pytest.fixture
 def client(app):
-    '''
+    """
     Fixes https://github.com/pytest-dev/pytest-flask/issues/42
-    '''
+    """
     return app.test_client()
 
 
 def get_settings(request):
-    '''
+    """
     Extract settings from the current test request
-    '''
-    marker = request.node.get_closest_marker('settings')
+    """
+    marker = request.node.get_closest_marker("settings")
     if marker:
         return marker.args[0]
-    _settings = getattr(request.cls, 'settings', settings.Testing)
+    _settings = getattr(request.cls, "settings", settings.Testing)
     # apply the options(plugins) marker from pytest_flask as soon as app is created
     # https://github.com/pytest-dev/pytest-flask/blob/a62ea18cb0fe89e3f3911192ab9ea4f9b12f8a16/pytest_flask/plugin.py#L126
     # this lets us have default settings for plugins applied while testing
-    plugins = getattr(_settings, 'PLUGINS', [])
-    for options in request.node.iter_markers('options'):
-        option = options.kwargs.get('plugins', []) or options.kwargs.get('PLUGINS', [])
+    plugins = getattr(_settings, "PLUGINS", [])
+    for options in request.node.iter_markers("options"):
+        option = options.kwargs.get("plugins", []) or options.kwargs.get("PLUGINS", [])
         plugins += option
-    setattr(_settings, 'PLUGINS', plugins)
+    setattr(_settings, "PLUGINS", plugins)
     return _settings
 
 
 def drop_db(app):
-    '''Clear the database'''
-    parsed_url = urlparse(app.config['MONGODB_HOST'])
+    """Clear the database"""
+    parsed_url = urlparse(app.config["MONGODB_HOST"])
 
     # drop the leading /
     db_name = parsed_url.path[1:]
@@ -133,19 +133,20 @@ def clean_db(app):
     yield
 
 
-@pytest.fixture(name='db')
+@pytest.fixture(name="db")
 def raw_db(app, clean_db):
-    '''Access to raw PyMongo DB client'''
+    """Access to raw PyMongo DB client"""
     from mongoengine.connection import get_db
+
     yield get_db()
     drop_db(app)
 
 
 @pytest.fixture
 def enable_resource_event(app):
-    '''Enable resource event'''
-    app.config['PUBLISH_ON_RESOURCE_EVENTS'] = True
-    app.config['RESOURCES_ANALYSER_URI'] = 'http://local.dev'
+    """Enable resource event"""
+    app.config["PUBLISH_ON_RESOURCE_EVENTS"] = True
+    app.config["RESOURCES_ANALYSER_URI"] = "http://local.dev"
 
 
 class ApiClient(object):
@@ -165,42 +166,42 @@ class ApiClient(object):
         yield self._user
 
     def perform(self, verb, url, **kwargs):
-        headers = kwargs.pop('headers', {})
-        headers['Content-Type'] = 'application/json'
+        headers = kwargs.pop("headers", {})
+        headers["Content-Type"] = "application/json"
 
-        data = kwargs.get('data')
+        data = kwargs.get("data")
         if data is not None:
             data = json.dumps(data)
-            headers['Content-Length'] = len(data)
-            kwargs['data'] = data
+            headers["Content-Length"] = len(data)
+            kwargs["data"] = data
 
         if self._user:
-            headers['X-API-KEY'] = kwargs.get('X-API-KEY', self._user.apikey)
+            headers["X-API-KEY"] = kwargs.get("X-API-KEY", self._user.apikey)
 
-        kwargs['headers'] = headers
+        kwargs["headers"] = headers
         method = getattr(self.client, verb)
         return method(url, **kwargs)
 
     def get(self, url, *args, **kwargs):
-        return self.perform('get', url, *args, **kwargs)
+        return self.perform("get", url, *args, **kwargs)
 
     def post(self, url, data=None, json=True, *args, **kwargs):
         if not json:
             return self.client.post(url, data or {}, *args, **kwargs)
-        return self.perform('post', url, data=data or {}, *args, **kwargs)
+        return self.perform("post", url, data=data or {}, *args, **kwargs)
 
     def put(self, url, data=None, json=True, *args, **kwargs):
         if not json:
             return self.client.put(url, data or {}, *args, **kwargs)
-        return self.perform('put', url, data=data or {}, *args, **kwargs)
+        return self.perform("put", url, data=data or {}, *args, **kwargs)
 
     def patch(self, url, data=None, json=True, *args, **kwargs):
         if not json:
             return self.client.patch(url, data or {}, *args, **kwargs)
-        return self.perform('patch', url, data=data or {}, *args, **kwargs)
+        return self.perform("patch", url, data=data or {}, *args, **kwargs)
 
     def delete(self, url, data=None, *args, **kwargs):
-        return self.perform('delete', url, data=data or {}, *args, **kwargs)
+        return self.perform("delete", url, data=data or {}, *args, **kwargs)
 
 
 @pytest.fixture
@@ -209,17 +210,16 @@ def api(client):
     return api_client
 
 
-@pytest.fixture(name='cli')
+@pytest.fixture(name="cli")
 def cli_fixture(app):
-
     def mock_runner(*args, **kwargs):
         from udata.commands import cli
 
-        if len(args) == 1 and ' ' in args[0]:
+        if len(args) == 1 and " " in args[0]:
             args = shlex.split(args[0])
         runner = app.test_cli_runner()
         result = runner.invoke(cli, args, catch_exceptions=False)
-        if kwargs.get('check', True):
+        if kwargs.get("check", True):
             assert_command_ok(result)
         return result
 
@@ -228,20 +228,20 @@ def cli_fixture(app):
 
 @pytest.fixture
 def instance_path(app, tmpdir):
-    '''Use temporary application instance_path'''
+    """Use temporary application instance_path"""
     from udata.core import storages
     from udata.core.storages.views import blueprint
 
     app.instance_path = str(tmpdir)
-    app.config['FS_ROOT'] = str(tmpdir / 'fs')
+    app.config["FS_ROOT"] = str(tmpdir / "fs")
     # Force local storage:
-    for s in 'resources', 'avatars', 'logos', 'images', 'chunks', 'tmp':
-        key = '{0}_FS_{{0}}'.format(s.upper())
-        app.config[key.format('BACKEND')] = 'local'
-        app.config.pop(key.format('ROOT'), None)
+    for s in "resources", "avatars", "logos", "images", "chunks", "tmp":
+        key = "{0}_FS_{{0}}".format(s.upper())
+        app.config[key.format("BACKEND")] = "local"
+        app.config.pop(key.format("ROOT"), None)
 
     storages.init_app(app)
-    app.register_blueprint(blueprint, name='test-storage')
+    app.register_blueprint(blueprint, name="test-storage")
 
     return tmpdir
 
@@ -277,8 +277,9 @@ class TemplateRecorder:
 
             used_templates.append(template)
 
-        msg = 'Template %s not used. Templates were used: %s' % (
-            name, ' '.join(repr(used_templates))
+        msg = "Template %s not used. Templates were used: %s" % (
+            name,
+            " ".join(repr(used_templates)),
         )
         raise AssertionError(msg)
 
@@ -305,6 +306,7 @@ def templates():
 @pytest.fixture
 def httpretty():
     import httpretty
+
     httpretty.reset()
     httpretty.enable()
     yield httpretty
@@ -313,8 +315,9 @@ def httpretty():
 
 @pytest.fixture
 def rmock():
-    '''A requests-mock fixture'''
+    """A requests-mock fixture"""
     import requests_mock
+
     with requests_mock.Mocker() as m:
         m.ANY = requests_mock.ANY
         yield m
@@ -322,7 +325,7 @@ def rmock():
 
 class SitemapClient:
     # Needed for lxml XPath not supporting default namespace
-    NAMESPACES = {'s': 'http://www.sitemaps.org/schemas/sitemap/0.9'}
+    NAMESPACES = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
     MISMATCH = 'URL "{0}" {1} mismatch: expected "{2}" found "{3}"'
 
     def __init__(self, client):
@@ -330,8 +333,8 @@ class SitemapClient:
         self._sitemap = None
 
     def fetch(self, secure=False):
-        base_url = '{0}://local.test'.format('https' if secure else 'http')
-        response = self.client.get('sitemap.xml', base_url=base_url)
+        base_url = "{0}://local.test".format("https" if secure else "http")
+        response = self.client.get("sitemap.xml", base_url=base_url)
         assert200(response)
         self._sitemap = etree.fromstring(response.data)
         return self._sitemap
@@ -346,21 +349,21 @@ class SitemapClient:
         return result[0] if result else None
 
     def assert_url(self, url, priority, changefreq):
-        '''
+        """
         Check than a URL is present in the sitemap
         with given `priority` and `changefreq`
-        '''
+        """
         __tracebackhide__ = True
-        r = url.xpath('s:priority', namespaces=self.NAMESPACES)
+        r = url.xpath("s:priority", namespaces=self.NAMESPACES)
         assert len(r) == 1, 'URL "{0}" should have one priority'.format(url)
         found = r[0].text
-        msg = self.MISMATCH.format(url, 'priority', priority, found)
+        msg = self.MISMATCH.format(url, "priority", priority, found)
         assert found == str(priority), msg
 
-        r = url.xpath('s:changefreq', namespaces=self.NAMESPACES)
+        r = url.xpath("s:changefreq", namespaces=self.NAMESPACES)
         assert len(r) == 1, 'URL "{0}" should have one changefreq'.format(url)
         found = r[0].text
-        msg = self.MISMATCH.format(url, 'changefreq', changefreq, found)
+        msg = self.MISMATCH.format(url, "changefreq", changefreq, found)
         assert found == changefreq, msg
 
 

udata/tests/reuse/test_reuse_model.py

@@ -1,17 +1,16 @@
 from datetime import datetime
 
-from udata.models import Reuse
-
 from udata.core.dataset import tasks as dataset_tasks
+from udata.core.dataset.factories import DatasetFactory
+from udata.core.discussions.factories import DiscussionFactory
 from udata.core.organization.factories import OrganizationFactory
 from udata.core.reuse.factories import ReuseFactory, VisibleReuseFactory
-from udata.core.dataset.factories import DatasetFactory
 from udata.core.user.factories import UserFactory
-from udata.core.discussions.factories import DiscussionFactory
 from udata.i18n import gettext as _
+from udata.models import Reuse
 from udata.tests.helpers import assert_emit
 
-from .. import TestCase, DBTestMixin
+from .. import DBTestMixin, TestCase
 
 
 class ReuseModelTest(TestCase, DBTestMixin):
@@ -39,8 +38,10 @@ class ReuseModelTest(TestCase, DBTestMixin):
         user = UserFactory()
         org = OrganizationFactory()
         reuses = [ReuseFactory(owner=user), ReuseFactory(organization=org)]
-        excluded = [ReuseFactory(owner=UserFactory()),
-                    ReuseFactory(organization=OrganizationFactory())]
+        excluded = [
+            ReuseFactory(owner=UserFactory()),
+            ReuseFactory(organization=OrganizationFactory()),
+        ]
 
         result = Reuse.objects.owned_by(org, user)
 
@@ -53,10 +54,10 @@ class ReuseModelTest(TestCase, DBTestMixin):
 
     def test_tags_normalized(self):
         user = UserFactory()
-        tags = [' one another!', ' one another!', 'This IS a "tag"…']
+        tags = [" one another!", " one another!", 'This IS a "tag"…']
         reuse = ReuseFactory(owner=user, tags=tags)
         self.assertEqual(len(reuse.tags), 2)
-        self.assertEqual(reuse.tags[1], 'this-is-a-tag')
+        self.assertEqual(reuse.tags[1], "this-is-a-tag")
 
     def test_send_on_delete(self):
         reuse = ReuseFactory()
@@ -72,18 +73,18 @@ class ReuseModelTest(TestCase, DBTestMixin):
         reuse.count_datasets()
         reuse.count_discussions()
 
-        assert reuse.get_metrics()['datasets'] == 1
-        assert reuse.get_metrics()['discussions'] == 1
+        assert reuse.get_metrics()["datasets"] == 1
+        assert reuse.get_metrics()["discussions"] == 1
 
         with assert_emit(Reuse.on_update):
             reuse.datasets.append(dataset)
             reuse.save()
 
         reuse.count_datasets()
-        assert reuse.get_metrics()['datasets'] == 2
+        assert reuse.get_metrics()["datasets"] == 2
 
         dataset.count_reuses()
-        assert dataset.get_metrics()['reuses'] == 1
+        assert dataset.get_metrics()["reuses"] == 1
 
         with assert_emit(Reuse.on_update):
             reuse.datasets.remove(dataset)
@@ -91,17 +92,17 @@ class ReuseModelTest(TestCase, DBTestMixin):
 
         dataset_tasks.update_datasets_reuses_metrics()
         dataset.reload()
-        assert dataset.get_metrics()['reuses'] == 0
+        assert dataset.get_metrics()["reuses"] == 0
 
     def test_reuse_type(self):
-        reuse = ReuseFactory(type='api')
-        self.assertEqual(reuse.type, 'api')
-        self.assertEqual(reuse.type_label, 'API')
+        reuse = ReuseFactory(type="api")
+        self.assertEqual(reuse.type, "api")
+        self.assertEqual(reuse.type_label, "API")
 
     def test_reuse_topic(self):
-        reuse = ReuseFactory(topic='health')
-        self.assertEqual(reuse.topic, 'health')
-        self.assertEqual(reuse.topic_label, _('Health'))
+        reuse = ReuseFactory(topic="health")
+        self.assertEqual(reuse.topic, "health")
+        self.assertEqual(reuse.topic_label, _("Health"))
 
     def test_reuse_without_private(self):
         reuse = ReuseFactory()
@@ -114,4 +115,3 @@ class ReuseModelTest(TestCase, DBTestMixin):
         reuse.private = True
         reuse.save()
         self.assertEqual(reuse.private, True)
-

udata/tests/reuse/test_reuse_task.py

@@ -1,31 +1,29 @@
 from flask import url_for
 
-from udata.tests.api import APITestCase
-
 from udata.core import storages
-from udata.tests.helpers import create_test_image
-from udata.models import Reuse, Transfer
-from udata.core.user.factories import AdminFactory, UserFactory
-from udata.core.reuse.factories import ReuseFactory
 from udata.core.reuse import tasks
+from udata.core.reuse.factories import ReuseFactory
+from udata.core.user.factories import AdminFactory, UserFactory
+from udata.models import Reuse, Transfer
+from udata.tests.api import APITestCase
+from udata.tests.helpers import create_test_image
 
 
 class ReuseTasksTest(APITestCase):
     def test_purge_reuses(self):
-        reuse = ReuseFactory(title='test-reuse')
+        reuse = ReuseFactory(title="test-reuse")
 
         # Upload reuse's image
         file = create_test_image()
         user = AdminFactory()
         self.login(user)
         response = self.post(
-            url_for('api.reuse_image', reuse=reuse),
-            {'file': (file, 'test.png')},
-            json=False)
+            url_for("api.reuse_image", reuse=reuse), {"file": (file, "test.png")}, json=False
+        )
         self.assert200(response)
 
         # Delete reuse
-        response = self.delete(url_for('api.reuse', reuse=reuse))
+        response = self.delete(url_for("api.reuse", reuse=reuse))
         self.assert204(response)
 
         user = UserFactory()
@@ -33,7 +31,7 @@ class ReuseTasksTest(APITestCase):
             owner=user,
             recipient=user,
             subject=reuse,
-            comment='comment',
+            comment="comment",
         )
 
         tasks.purge_reuses()
@@ -43,5 +41,5 @@ class ReuseTasksTest(APITestCase):
         # Check reuse's image is deleted
         self.assertEqual(list(storages.images.list_files()), [])
 
-        deleted_reuse = Reuse.objects(title='test-reuse').first()
+        deleted_reuse = Reuse.objects(title="test-reuse").first()
         self.assertIsNone(deleted_reuse)

udata/tests/search/__init__.py

@@ -1,15 +1,14 @@
 import factory
-
 from factory.mongoengine import MongoEngineFactory
 
 from udata import search
 from udata.mongo import db
 
-
 #############################################################################
 #                           Fake object for testing                         #
 #############################################################################
 
+
 class FakeSearchable(db.Document):
     title = db.StringField()
     description = db.StringField()
@@ -17,7 +16,7 @@ class FakeSearchable(db.Document):
     other = db.ListField(db.StringField())
     indexable = db.BooleanField(default=True)
 
-    meta = {'allow_inheritance': True}
+    meta = {"allow_inheritance": True}
 
     def __unicode__(self):
         return self.title
@@ -26,11 +25,11 @@ class FakeSearchable(db.Document):
         return self.title
 
     def __html__(self):
-        return '<span>{0}</span>'.format(self.title)
+        return "<span>{0}</span>".format(self.title)
 
 
 class FakeFactory(MongoEngineFactory):
-    title = factory.Faker('sentence')
+    title = factory.Faker("sentence")
 
     class Meta:
         model = FakeSearchable
@@ -39,14 +38,14 @@ class FakeFactory(MongoEngineFactory):
 @search.register
 class FakeSearch(search.ModelSearchAdapter):
     model = FakeSearchable
-    search_url = 'mock://test.com/fakeable/'
+    search_url = "mock://test.com/fakeable/"
     filters = {
-        'tag': search.Filter(),
-        'other': search.Filter(),
+        "tag": search.Filter(),
+        "other": search.Filter(),
     }
     sorts = {
-        'title': 'title.raw',
-        'description': 'description.raw',
+        "title": "title.raw",
+        "description": "description.raw",
     }
 
     @classmethod
@@ -56,6 +55,6 @@ class FakeSearch(search.ModelSearchAdapter):
     @classmethod
     def serialize(cls, fake):
         return {
-            'title': fake.title,
-            'description': fake.description,
+            "title": fake.title,
+            "description": fake.description,
         }