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

udata/tests/test_i18n.py

@@ -1,32 +1,31 @@
-from flask import g, url_for, render_template_string
+from flask import g, render_template_string, url_for
 from werkzeug.routing import BuildError
 
-from udata.i18n import I18nBlueprint, language
-
-from . import DBTestMixin, WebTestMixin, TestCase
 from udata.core.user.factories import UserFactory
+from udata.i18n import I18nBlueprint, language
 
+from . import DBTestMixin, TestCase, WebTestMixin
 
-bp = I18nBlueprint('i18nbp', __name__, static_folder='static')
+bp = I18nBlueprint("i18nbp", __name__, static_folder="static")
 
 
-@bp.route('/lang/<msg>/')
+@bp.route("/lang/<msg>/")
 def lang(msg):
     return g.lang_code
 
 
-@bp.route('/hardcoded/')
+@bp.route("/hardcoded/")
 def hardcoded():
-    out = g.lang_code + '-'
-    with language('fr'):
+    out = g.lang_code + "-"
+    with language("fr"):
         out += g.lang_code
     return out
 
 
-@bp.route('/not-localized/', localize=False)
+@bp.route("/not-localized/", localize=False)
 def not_localized():
-    out = g.lang_code + '-'
-    with language('fr'):
+    out = g.lang_code + "-"
+    with language("fr"):
         out += g.lang_code
     return out
 
@@ -34,63 +33,61 @@ def not_localized():
 class I18nBlueprintTest(WebTestMixin, DBTestMixin, TestCase):
     def create_app(self):
         app = super(I18nBlueprintTest, self).create_app()
-        app.config['DEFAULT_LANGUAGE'] = 'en'
-        app.config['LANGUAGES'] = {
-            'en': 'English',
-            'fr': 'Français',
+        app.config["DEFAULT_LANGUAGE"] = "en"
+        app.config["LANGUAGES"] = {
+            "en": "English",
+            "fr": "Français",
         }
         app.register_blueprint(bp)
         return app
 
     def test_lang_inserted_url_for(self):
-        self.assertEqual(url_for('i18nbp.lang', msg='test'), '/en/lang/test/')
+        self.assertEqual(url_for("i18nbp.lang", msg="test"), "/en/lang/test/")
 
     def test_redirect_url_for(self):
-        self.assertEqual(
-            url_for('i18nbp.lang_redirect', msg='test'), '/lang/test/')
+        self.assertEqual(url_for("i18nbp.lang_redirect", msg="test"), "/lang/test/")
 
     def test_lang_ignored_for_static(self):
-        self.assertEqual(url_for('i18nbp.static', filename='test.jpg'),
-                         '/static/test.jpg')
+        self.assertEqual(url_for("i18nbp.static", filename="test.jpg"), "/static/test.jpg")
         with self.assertRaises(BuildError):
-            url_for('i18nbp.static_redirect', filename='test.jpg')
+            url_for("i18nbp.static_redirect", filename="test.jpg")
 
     def test_redirect_on_missing_lang(self):
-        response = self.get('/lang/test/?q=test')
-        self.assertRedirects(response, '/en/lang/test/?q=test')
+        response = self.get("/lang/test/?q=test")
+        self.assertRedirects(response, "/en/lang/test/?q=test")
 
     def test_do_not_redirect_and_set_lang(self):
-        self.assertEqual(self.get('/fr/lang/test/').data, b'fr')
-        self.assertEqual(self.get('/en/lang/test/').data, b'en')
+        self.assertEqual(self.get("/fr/lang/test/").data, b"fr")
+        self.assertEqual(self.get("/en/lang/test/").data, b"en")
 
     def test_redirect_on_default_lang_for_unknown_lang(self):
-        self.assertRedirects(self.get('/sk/lang/test/'), '/en/lang/test/')
+        self.assertRedirects(self.get("/sk/lang/test/"), "/en/lang/test/")
 
     def test_404_on_default_lang_for_unknown_lang(self):
-        self.assert404(self.get('/sk/not-found/'))
+        self.assert404(self.get("/sk/not-found/"))
 
     def test_language_contact_manager(self):
-        self.assertEqual(self.get('/fr/hardcoded/').data, b'fr-fr')
-        self.assertEqual(self.get('/en/hardcoded/').data, b'en-fr')
+        self.assertEqual(self.get("/fr/hardcoded/").data, b"fr-fr")
+        self.assertEqual(self.get("/en/hardcoded/").data, b"en-fr")
 
     def test_redirect_user_prefered_lang(self):
-        self.login(UserFactory(prefered_language='fr'))
+        self.login(UserFactory(prefered_language="fr"))
 
-        response = self.get('/lang/test/?q=test')
-        self.assertRedirects(response, '/fr/lang/test/?q=test')
+        response = self.get("/lang/test/?q=test")
+        self.assertRedirects(response, "/fr/lang/test/?q=test")
 
     def test_lang_ignored_for_localize_false(self):
-        url = url_for('i18nbp.not_localized')
-        self.assertEqual(url, '/not-localized/')
+        url = url_for("i18nbp.not_localized")
+        self.assertEqual(url, "/not-localized/")
 
     def test_localized_url_redirect_for_localize_false(self):
-        url = url_for('i18nbp.not_localized_redirect')
-        self.assertEqual(url, '/en/not-localized/')
+        url = url_for("i18nbp.not_localized_redirect")
+        self.assertEqual(url, "/en/not-localized/")
 
         response = self.get(url)
-        self.assertRedirects(response, '/not-localized/')
+        self.assertRedirects(response, "/not-localized/")
 
     def test_render_template_translation(self):
-        '''It should render the dataset page'''
-        self.app.config['DEFAULT_LANGUAGE'] = 'fr'
+        """It should render the dataset page"""
+        self.app.config["DEFAULT_LANGUAGE"] = "fr"
         self.assertEqual("Bienvenue", render_template_string('{{ _("Welcome") }}'))

udata/tests/test_linkchecker.py

@@ -1,21 +1,22 @@
+from datetime import datetime, timedelta
+
 import mock
 import pytest
-from datetime import datetime, timedelta
 
 from udata.auth import login_user
-from udata.tests import TestCase
 from udata.core.activity import init_app as init_activity
 from udata.core.activity.models import Activity
 from udata.core.dataset.factories import DatasetFactory, ResourceFactory
 from udata.core.user.factories import UserFactory
 from udata.linkchecker.checker import check_resource
 from udata.settings import Testing
+from udata.tests import TestCase
 
 
 class LinkcheckerTestSettings(Testing):
     LINKCHECKING_ENABLED = True
-    LINKCHECKING_IGNORE_DOMAINS = ['example-ignore.com']
-    LINKCHECKING_IGNORE_PATTERNS = ['format=shp']
+    LINKCHECKING_IGNORE_DOMAINS = ["example-ignore.com"]
+    LINKCHECKING_IGNORE_PATTERNS = ["format=shp"]
     LINKCHECKING_MIN_CACHE_DURATION = 0.5
     LINKCHECKING_UNAVAILABLE_THRESHOLD = 100
     LINKCHECKING_MAX_CACHE_DURATION = 100
@@ -32,14 +33,13 @@ def test_check_resource_creates_no_activity(activity_app, mocker):
     dataset = DatasetFactory(resources=[resource])
     user = UserFactory()
     login_user(user)
-    check_res = {'check:status': 200, 'check:available': True,
-                 'check:date': datetime.utcnow()}
+    check_res = {"check:status": 200, "check:available": True, "check:date": datetime.utcnow()}
 
     class DummyLinkchecker:
         def check(self, _):
             return check_res
-    mocker.patch('udata.linkchecker.checker.get_linkchecker',
-                 return_value=DummyLinkchecker)
+
+    mocker.patch("udata.linkchecker.checker.get_linkchecker", return_value=DummyLinkchecker)
 
     check_resource(resource)
 
@@ -54,95 +54,98 @@ class LinkcheckerTest(TestCase):
         self.resource = ResourceFactory()
         self.dataset = DatasetFactory(resources=[self.resource])
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_no_linkchecker(self, mock_fn):
         mock_fn.return_value = None
         res = check_resource(self.resource)
-        self.assertEqual(res, ({'error': 'No linkchecker configured.'}, 503))
+        self.assertEqual(res, ({"error": "No linkchecker configured."}, 503))
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_linkchecker_ok(self, mock_fn):
-        check_res = {'check:status': 200, 'check:available': True,
-                     'check:date': datetime.utcnow()}
+        check_res = {"check:status": 200, "check:available": True, "check:date": datetime.utcnow()}
 
         class DummyLinkchecker:
             def check(self, _):
                 return check_res
+
         mock_fn.return_value = DummyLinkchecker
 
         res = check_resource(self.resource)
         self.assertEqual(res, check_res)
-        check_res.update({'check:count-availability': 1})
+        check_res.update({"check:count-availability": 1})
         self.assertEqual(self.resource.extras, check_res)
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_filter_result(self, mock_fn):
-        check_res = {'check:status': 200, 'dummy': 'dummy'}
+        check_res = {"check:status": 200, "dummy": "dummy"}
 
         class DummyLinkchecker:
             def check(self, _):
                 return check_res
+
         mock_fn.return_value = DummyLinkchecker
 
         res = check_resource(self.resource)
         self.assertEqual(res, check_res)
-        self.assertNotIn('dummy', self.resource.extras)
+        self.assertNotIn("dummy", self.resource.extras)
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_linkchecker_no_status(self, mock_fn):
         class DummyLinkchecker:
             def check(self, _):
-                return {'check:available': True}
+                return {"check:available": True}
+
         mock_fn.return_value = DummyLinkchecker
         res = check_resource(self.resource)
-        self.assertEqual(res,
-                          ({'error': 'No status in response from linkchecker'},
-                           503))
+        self.assertEqual(res, ({"error": "No status in response from linkchecker"}, 503))
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_linkchecker_check_error(self, mock_fn):
         class DummyLinkchecker:
             def check(self, _):
-                return {'check:error': 'ERROR'}
+                return {"check:error": "ERROR"}
+
         mock_fn.return_value = DummyLinkchecker
         res = check_resource(self.resource)
-        self.assertEqual(res, ({'error': 'ERROR'}, 500))
+        self.assertEqual(res, ({"error": "ERROR"}, 500))
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_check_resource_linkchecker_in_resource(self, mock_fn):
-        self.resource.extras['check:checker'] = 'another_linkchecker'
+        self.resource.extras["check:checker"] = "another_linkchecker"
         self.resource.save()
         check_resource(self.resource)
         args, kwargs = mock_fn.call_args
-        self.assertEqual(args, ('another_linkchecker', ))
+        self.assertEqual(args, ("another_linkchecker",))
 
     def test_check_resource_linkchecker_no_check(self):
-        self.resource.extras['check:checker'] = 'no_check'
+        self.resource.extras["check:checker"] = "no_check"
         self.resource.save()
         res = check_resource(self.resource)
-        self.assertEqual(res.get('check:status'), 204)
-        self.assertEqual(res.get('check:available'), True)
+        self.assertEqual(res.get("check:status"), 204)
+        self.assertEqual(res.get("check:available"), True)
 
     def test_check_resource_ignored_domain(self):
         self.resource.extras = {}
-        self.resource.url = 'http://example-ignore.com/url'
+        self.resource.url = "http://example-ignore.com/url"
         self.resource.save()
         res = check_resource(self.resource)
-        self.assertEqual(res.get('check:status'), 204)
-        self.assertEqual(res.get('check:available'), True)
+        self.assertEqual(res.get("check:status"), 204)
+        self.assertEqual(res.get("check:available"), True)
 
     def test_check_resource_ignored_pattern(self):
         self.resource.extras = {}
-        self.resource.url = 'http://example.com/url?format=shp'
+        self.resource.url = "http://example.com/url?format=shp"
         self.resource.save()
         res = check_resource(self.resource)
-        self.assertEqual(res.get('check:status'), 204)
-        self.assertEqual(res.get('check:available'), True)
+        self.assertEqual(res.get("check:status"), 204)
+        self.assertEqual(res.get("check:available"), True)
 
     def test_is_need_check(self):
-        self.resource.extras = {'check:available': True,
-                                'check:date': datetime.utcnow(),
-                                'check:status': 42}
+        self.resource.extras = {
+            "check:available": True,
+            "check:date": datetime.utcnow(),
+            "check:status": 42,
+        }
         self.assertFalse(self.resource.need_check())
 
     def test_is_need_check_unknown_status(self):
@@ -151,56 +154,56 @@ class LinkcheckerTest(TestCase):
 
     def test_is_need_check_cache_expired(self):
         self.resource.extras = {
-            'check:available': True,
-            'check:date': datetime.utcnow() - timedelta(seconds=3600),
-            'check:status': 42
+            "check:available": True,
+            "check:date": datetime.utcnow() - timedelta(seconds=3600),
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
     def test_is_need_check_date_string(self):
         check_date = (datetime.utcnow() - timedelta(seconds=3600)).isoformat()
         self.resource.extras = {
-            'check:available': True,
-            'check:date': check_date,
-            'check:status': 42
+            "check:available": True,
+            "check:date": check_date,
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
     def test_is_need_check_wrong_check_date(self):
-        check_date = '123azerty'
+        check_date = "123azerty"
         self.resource.extras = {
-            'check:available': True,
-            'check:date': check_date,
-            'check:status': 42
+            "check:available": True,
+            "check:date": check_date,
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
     def test_is_need_check_wrong_check_date_int(self):
         check_date = 42
         self.resource.extras = {
-            'check:available': True,
-            'check:date': check_date,
-            'check:status': 42
+            "check:available": True,
+            "check:date": check_date,
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
     def test_is_need_check_count_availability(self):
         self.resource.extras = {
             # should need a new check after 100 * 30s = 3000s < 3600s
-            'check:count-availability': 100,
-            'check:available': True,
-            'check:date': datetime.utcnow() - timedelta(seconds=3600),
-            'check:status': 42
+            "check:count-availability": 100,
+            "check:available": True,
+            "check:date": datetime.utcnow() - timedelta(seconds=3600),
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
     def test_is_need_check_count_availability_expired(self):
         self.resource.extras = {
             # should need a new check after 150 * 30s = 4500s > 3600s
-            'check:count-availability': 150,
-            'check:available': True,
-            'check:date': datetime.utcnow() - timedelta(seconds=3600),
-            'check:status': 42
+            "check:count-availability": 150,
+            "check:available": True,
+            "check:date": datetime.utcnow() - timedelta(seconds=3600),
+            "check:status": 42,
         }
         self.assertFalse(self.resource.need_check())
 
@@ -208,64 +211,67 @@ class LinkcheckerTest(TestCase):
         self.resource.extras = {
             # should need a new check after 30s < 3600S
             # count-availability is below threshold
-            'check:count-availability': 95,
-            'check:available': False,
-            'check:date': datetime.utcnow() - timedelta(seconds=3600),
-            'check:status': 42
+            "check:count-availability": 95,
+            "check:available": False,
+            "check:date": datetime.utcnow() - timedelta(seconds=3600),
+            "check:status": 42,
         }
         self.assertTrue(self.resource.need_check())
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_count_availability_increment(self, mock_fn):
-        check_res = {'check:status': 200, 'check:available': True,
-                     'check:date': datetime.utcnow()}
+        check_res = {"check:status": 200, "check:available": True, "check:date": datetime.utcnow()}
 
         class DummyLinkchecker:
             def check(self, _):
                 return check_res
+
         mock_fn.return_value = DummyLinkchecker
 
         check_resource(self.resource)
-        self.assertEqual(self.resource.extras['check:count-availability'], 1)
+        self.assertEqual(self.resource.extras["check:count-availability"], 1)
 
         check_resource(self.resource)
-        self.assertEqual(self.resource.extras['check:count-availability'], 2)
+        self.assertEqual(self.resource.extras["check:count-availability"], 2)
 
-    @mock.patch('udata.linkchecker.checker.get_linkchecker')
+    @mock.patch("udata.linkchecker.checker.get_linkchecker")
     def test_count_availability_reset(self, mock_fn):
-        self.resource.extras = {'check:status': 200, 'check:available': True,
-                                'check:date': datetime.utcnow(),
-                                'check:count-availability': 2}
-        check_res = {'check:status': 200, 'check:available': False,
-                     'check:date': datetime.utcnow()}
+        self.resource.extras = {
+            "check:status": 200,
+            "check:available": True,
+            "check:date": datetime.utcnow(),
+            "check:count-availability": 2,
+        }
+        check_res = {"check:status": 200, "check:available": False, "check:date": datetime.utcnow()}
 
         class DummyLinkchecker:
             def check(self, _):
                 return check_res
+
         mock_fn.return_value = DummyLinkchecker
 
         check_resource(self.resource)
-        self.assertEqual(self.resource.extras['check:count-availability'], 1)
+        self.assertEqual(self.resource.extras["check:count-availability"], 1)
 
     def test_count_availability_threshold(self):
         self.resource.extras = {
-            'check:status': 404,
-            'check:available': False,
+            "check:status": 404,
+            "check:available": False,
             # if it weren't above threshold, should need check (>30s)
             # and we're still below max_cache 101 * 0.5 < 100
-            'check:date': datetime.utcnow() - timedelta(seconds=60),
-            'check:count-availability': 101
+            "check:date": datetime.utcnow() - timedelta(seconds=60),
+            "check:count-availability": 101,
         }
         self.assertFalse(self.resource.need_check())
 
     def test_count_availability_max_cache_duration(self):
         self.resource.extras = {
-            'check:status': 200,
-            'check:available': True,
+            "check:status": 200,
+            "check:available": True,
             # next check should be at 300 * 0.5 = 150min
             # but we are above max cache duration 150min > 100min
             # and 120m > 100 min so we should need a new check
-            'check:date': datetime.utcnow() - timedelta(minutes=120),
-            'check:count-availability': 300
+            "check:date": datetime.utcnow() - timedelta(minutes=120),
+            "check:count-availability": 300,
         }
         self.assertTrue(self.resource.need_check())

udata/tests/test_mail.py

@@ -4,25 +4,21 @@ from smtplib import SMTPRecipientsRefused
 import pytest
 
 from udata.core.user.factories import UserFactory
-from udata.mail import send, mail_sent
-from udata.tests import TestCase, DBTestMixin
+from udata.mail import mail_sent, send
+from udata.tests import DBTestMixin, TestCase
 from udata.tests.helpers import assert_emit, assert_not_emit
 
+SMTPRecipientsRefusedList = ["not-found@udata", "not-found-either@udata"]
 
-SMTPRecipientsRefusedList = [
-    'not-found@udata',
-    'not-found-either@udata'
-]
 
-
-class FakeSender():
+class FakeSender:
     def send(self, msg):
         if all(recipient in SMTPRecipientsRefusedList for recipient in msg.recipients):
             raise SMTPRecipientsRefused(msg.recipients)
         mail_sent.send(msg)
 
 
-class FakeMail():
+class FakeMail:
     @contextmanager
     def connect(*args, **kw):
         yield FakeSender()
@@ -31,26 +27,26 @@ class FakeMail():
 class MailSendTest(TestCase, DBTestMixin):
     def create_app(self):
         app = super().create_app()
-        app.config['SEND_MAIL'] = True
+        app.config["SEND_MAIL"] = True
         return app
 
     @pytest.fixture(autouse=True)
     def patch_mail(self, mocker):
-        mocker.patch('udata.mail.mail', FakeMail())
+        mocker.patch("udata.mail.mail", FakeMail())
 
     def test_send_mail(self):
         with assert_emit(mail_sent):
-            send('subject', [UserFactory(email='recipient@udata')], 'base')
+            send("subject", [UserFactory(email="recipient@udata")], "base")
 
     def test_send_mail_to_not_found_recipients(self):
         with assert_not_emit(mail_sent):
-            send('subject', [UserFactory(email='not-found@udata')], 'base')
+            send("subject", [UserFactory(email="not-found@udata")], "base")
 
     def test_send_mail_to_multiple_recipients_with_some_not_found(self):
         recipients = [
-            UserFactory(email='not-found@udata'),
-            UserFactory(email='recipient@udata'),
-            UserFactory(email='not-found-either@udata')
+            UserFactory(email="not-found@udata"),
+            UserFactory(email="recipient@udata"),
+            UserFactory(email="not-found-either@udata"),
         ]
         with assert_emit(mail_sent):
-            send('subject', recipients, 'base')
+            send("subject", recipients, "base")