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

udata/tests/workers/test_workers_api.py

@@ -5,288 +5,282 @@ from flask import url_for
 from udata.core.jobs.models import PeriodicTask
 from udata.core.user.factories import AdminFactory
 from udata.tasks import celery, job
-from udata.utils import faker
-
 from udata.tests.api import APITestCase
+from udata.utils import faker
 
 
 class JobsAPITest(APITestCase):
     def test_schedulable_jobs_list(self):
-        @celery.task(name='a-schedulable-job', schedulable=True)
+        @celery.task(name="a-schedulable-job", schedulable=True)
         def test_job():
             pass
 
-        response = self.get(url_for('api.schedulable_jobs'))
+        response = self.get(url_for("api.schedulable_jobs"))
         self.assert200(response)
-        self.assertIn('a-schedulable-job', response.json)
+        self.assertIn("a-schedulable-job", response.json)
 
     def test_schedulable_jobs_list_with_decorator(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
-        response = self.get(url_for('api.schedulable_jobs'))
+        response = self.get(url_for("api.schedulable_jobs"))
         self.assert200(response)
-        self.assertIn('a-job', response.json)
+        self.assertIn("a-job", response.json)
 
     def test_scheduled_jobs_list(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         for i in range(6):
-            params = {
-                'name': faker.name(),
-                'description': faker.sentence(),
-                'task': 'a-job'
-            }
+            params = {"name": faker.name(), "description": faker.sentence(), "task": "a-job"}
             if i % 2:
-                params['crontab'] = PeriodicTask.Crontab(minute=str(i))
+                params["crontab"] = PeriodicTask.Crontab(minute=str(i))
             else:
-                params['interval'] = PeriodicTask.Interval(every=i,
-                                                           period='minutes')
+                params["interval"] = PeriodicTask.Interval(every=i, period="minutes")
             PeriodicTask.objects.create(**params)
 
-        response = self.get(url_for('api.jobs'))
+        response = self.get(url_for("api.jobs"))
         self.assert200(response)
 
     def test_create_job_need_admin(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         data = {
-            'name': 'A crontab job',
-            'description': 'A simple crontab job doing nothing',
-            'task': 'a-job',
+            "name": "A crontab job",
+            "description": "A simple crontab job doing nothing",
+            "task": "a-job",
         }
 
         self.login()
-        response = self.post(url_for('api.jobs'), data)
+        response = self.post(url_for("api.jobs"), data)
         self.assert403(response)
 
     def test_create_crontab_job(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         data = {
-            'name': 'A crontab job',
-            'description': 'A simple crontab job doing nothing',
-            'task': 'a-job',
-            'crontab': {
-                'minute': '0',
-                'hour': '0'
-            }
+            "name": "A crontab job",
+            "description": "A simple crontab job doing nothing",
+            "task": "a-job",
+            "crontab": {"minute": "0", "hour": "0"},
         }
 
         self.login(AdminFactory())
-        response = self.post(url_for('api.jobs'), data)
+        response = self.post(url_for("api.jobs"), data)
         self.assert201(response)
 
-        self.assertEqual(response.json['name'], data['name'])
-        self.assertEqual(response.json['description'], data['description'])
-        self.assertEqual(response.json['task'], data['task'])
-        self.assertEqual(response.json['crontab'], {
-            'minute': '0',
-            'hour': '0',
-            'day_of_week': '*',
-            'day_of_month': '*',
-            'month_of_year': '*',
-        })
+        self.assertEqual(response.json["name"], data["name"])
+        self.assertEqual(response.json["description"], data["description"])
+        self.assertEqual(response.json["task"], data["task"])
+        self.assertEqual(
+            response.json["crontab"],
+            {
+                "minute": "0",
+                "hour": "0",
+                "day_of_week": "*",
+                "day_of_month": "*",
+                "month_of_year": "*",
+            },
+        )
 
     def test_create_interval_job(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         data = {
-            'name': 'An interval job',
-            'description': 'A simple interval job doing nothing',
-            'task': 'a-job',
-            'interval': {
-                'every': 5,
-                'period': 'minutes'
-            }
+            "name": "An interval job",
+            "description": "A simple interval job doing nothing",
+            "task": "a-job",
+            "interval": {"every": 5, "period": "minutes"},
         }
 
         self.login(AdminFactory())
-        response = self.post(url_for('api.jobs'), data)
+        response = self.post(url_for("api.jobs"), data)
         self.assert201(response)
 
-        self.assertEqual(response.json['name'], data['name'])
-        self.assertEqual(response.json['description'], data['description'])
-        self.assertEqual(response.json['task'], data['task'])
-        self.assertEqual(response.json['interval'], data['interval'])
+        self.assertEqual(response.json["name"], data["name"])
+        self.assertEqual(response.json["description"], data["description"])
+        self.assertEqual(response.json["task"], data["task"])
+        self.assertEqual(response.json["interval"], data["interval"])
 
     def test_fail_on_create_with_both_crontab_and_interval(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         data = {
-            'name': 'A mixed job',
-            'description': 'A simple crontab job doing nothing',
-            'task': 'a-job',
-            'crontab': {
-                'minute': '0',
-                'hour': '0'
-            },
-            'interval': {
-                'every': 5,
-                'period': 'minutes'
-            }
+            "name": "A mixed job",
+            "description": "A simple crontab job doing nothing",
+            "task": "a-job",
+            "crontab": {"minute": "0", "hour": "0"},
+            "interval": {"every": 5, "period": "minutes"},
         }
 
         self.login(AdminFactory())
-        response = self.post(url_for('api.jobs'), data)
+        response = self.post(url_for("api.jobs"), data)
         self.assertStatus(response, 400)
 
     def test_create_manual_job(self):
         pass
 
     def test_get_job(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
-        response = self.get(url_for('api.job', id=task.id))
+        response = self.get(url_for("api.job", id=task.id))
         self.assert200(response)
-        self.assertEqual(response.json['id'], str(task.id))
-        self.assertEqual(response.json['name'], task.name)
-        self.assertEqual(response.json['description'], task.description)
-        self.assertEqual(response.json['task'], task.task)
+        self.assertEqual(response.json["id"], str(task.id))
+        self.assertEqual(response.json["name"], task.name)
+        self.assertEqual(response.json["description"], task.description)
+        self.assertEqual(response.json["task"], task.task)
 
     def test_update_job_need_admin(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
         self.login()
-        response = self.put(url_for('api.job', id=task.id), {
-            'name': task.name,
-            'description': 'New description',
-            'task': task.task,
-            'crontab': task.crontab.to_json()
-        })
+        response = self.put(
+            url_for("api.job", id=task.id),
+            {
+                "name": task.name,
+                "description": "New description",
+                "task": task.task,
+                "crontab": task.crontab.to_json(),
+            },
+        )
         self.assert403(response)
 
     def test_update_job(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
         self.login(AdminFactory())
-        response = self.put(url_for('api.job', id=task.id), {
-            'name': task.name,
-            'description': 'New description',
-            'task': task.task,
-            'crontab': task.crontab.to_json()
-        })
+        response = self.put(
+            url_for("api.job", id=task.id),
+            {
+                "name": task.name,
+                "description": "New description",
+                "task": task.task,
+                "crontab": task.crontab.to_json(),
+            },
+        )
         self.assert200(response)
 
-        self.assertEqual(response.json['id'], str(task.id))
-        self.assertEqual(response.json['name'], task.name)
-        self.assertEqual(response.json['task'], task.task)
-        self.assertEqual(response.json['description'], 'New description')
-        self.assertIsNotNone(response.json['crontab'])
-        self.assertIsNone(response.json['interval'])
+        self.assertEqual(response.json["id"], str(task.id))
+        self.assertEqual(response.json["name"], task.name)
+        self.assertEqual(response.json["task"], task.task)
+        self.assertEqual(response.json["description"], "New description")
+        self.assertIsNotNone(response.json["crontab"])
+        self.assertIsNone(response.json["interval"])
 
     def test_update_job_change_type(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
         self.login(AdminFactory())
-        response = self.put(url_for('api.job', id=task.id), {
-            'name': task.name,
-            'description': task.description,
-            'task': task.task,
-            'interval': {
-                'every': 5,
-                'period': 'minutes',
-            }
-        })
+        response = self.put(
+            url_for("api.job", id=task.id),
+            {
+                "name": task.name,
+                "description": task.description,
+                "task": task.task,
+                "interval": {
+                    "every": 5,
+                    "period": "minutes",
+                },
+            },
+        )
         self.assert200(response)
 
-        self.assertEqual(response.json['id'], str(task.id))
-        self.assertEqual(response.json['name'], task.name)
-        self.assertEqual(response.json['task'], task.task)
-        self.assertEqual(response.json['description'], task.description)
-        self.assertEqual(response.json['interval']['every'], 5)
-        self.assertEqual(response.json['interval']['period'], 'minutes')
-        self.assertIsNone(response.json['crontab'])
+        self.assertEqual(response.json["id"], str(task.id))
+        self.assertEqual(response.json["name"], task.name)
+        self.assertEqual(response.json["task"], task.task)
+        self.assertEqual(response.json["description"], task.description)
+        self.assertEqual(response.json["interval"]["every"], 5)
+        self.assertEqual(response.json["interval"]["period"], "minutes")
+        self.assertIsNone(response.json["crontab"])
 
     def test_delete_job_need_admin(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
         self.login()
-        response = self.delete(url_for('api.job', id=task.id))
+        response = self.delete(url_for("api.job", id=task.id))
         self.assert403(response)
 
     def test_delete_job(self):
-        @job('a-job')
+        @job("a-job")
         def test_job():
             pass
 
         task = PeriodicTask.objects.create(
             name=faker.name(),
             description=faker.sentence(),
-            task='a-job',
-            crontab=PeriodicTask.Crontab(minute='5')
+            task="a-job",
+            crontab=PeriodicTask.Crontab(minute="5"),
         )
 
         self.login(AdminFactory())
-        response = self.delete(url_for('api.job', id=task.id))
+        response = self.delete(url_for("api.job", id=task.id))
         self.assert204(response)
 
         self.assertIsNone(PeriodicTask.objects(id=task.id).first())
 
-    @skip('Need to be mocked and more details')
+    @skip("Need to be mocked and more details")
     def test_get_task(self):
         @celery.task
         def test_task():
-            print('hello')
+            print("hello")
 
         result = test_task.delay()  # Always eager so no async
 
-        response = self.get(url_for('api.task', id=result.id))
+        response = self.get(url_for("api.task", id=result.id))
         self.assert200(response)
-        self.assertEqual(response.json['id'], result.id)
+        self.assertEqual(response.json["id"], result.id)

udata/tests/workers/test_workers_helpers.py

@@ -1,16 +1,16 @@
-from udata.tests import TestCase
 from udata.settings import Defaults
 from udata.tasks import default_scheduler_config
+from udata.tests import TestCase
 
 
 class DefaultSchedulerConfigTest(TestCase):
     def test_parse_default_value(self):
         db, url = default_scheduler_config(Defaults.MONGODB_HOST)
-        self.assertEqual(db, 'udata')
-        self.assertEqual(url, 'mongodb://localhost:27017')
+        self.assertEqual(db, "udata")
+        self.assertEqual(url, "mongodb://localhost:27017")
 
     def test_parse_url_with_auth(self):
-        full_url = 'mongodb://userid:password@somewhere.com:1234/mydb'
+        full_url = "mongodb://userid:password@somewhere.com:1234/mydb"
         db, url = default_scheduler_config(full_url)
-        self.assertEqual(db, 'mydb')
-        self.assertEqual(url, 'mongodb://userid:password@somewhere.com:1234')
+        self.assertEqual(db, "mydb")
+        self.assertEqual(url, "mongodb://userid:password@somewhere.com:1234")

udata/tracking.py

@@ -1,12 +1,10 @@
 def send_signal(signal, request, user, **kwargs):
-    '''Generic method to send signals to Piwik
+    """Generic method to send signals to Piwik
 
     given that we always have to compute IP and UID for instance.
-    '''
-    params = {
-        'user_ip': request.remote_addr
-    }
+    """
+    params = {"user_ip": request.remote_addr}
     params.update(kwargs)
     if user.is_authenticated:
-        params['uid'] = user.id
+        params["uid"] = user.id
     signal.send(request.url, **params)

udata/uris.py

@@ -1,48 +1,49 @@
 import re
 
-from werkzeug.routing import BuildError
 from flask import current_app, url_for
-from netaddr import IPAddress, AddrFormatError
-from udata.i18n import _
+from netaddr import AddrFormatError, IPAddress
+from werkzeug.routing import BuildError
 
+from udata.i18n import _
 from udata.settings import Defaults
 
 URL_REGEX = re.compile(
-    r'^'
+    r"^"
     # scheme
-    r'^(?:(?P<scheme>[a-z0-9\.\-]*):)?//'
+    r"^(?:(?P<scheme>[a-z0-9\.\-]*):)?//"
     # user:pass authentication
-    r'(?P<credentials>\S+(?::\S*)?@)?'
-    r'(?:'
+    r"(?P<credentials>\S+(?::\S*)?@)?"
+    r"(?:"
     # localhost
-    r'(?P<localhost>localhost(?:\.localdomain)?)'
-    r'|'
+    r"(?P<localhost>localhost(?:\.localdomain)?)"
+    r"|"
     # IPv4 addresses
-    r'(?P<ipv4>(?:\d{,3}\.){3}(?:\d{,3}))'
-    r'|'
+    r"(?P<ipv4>(?:\d{,3}\.){3}(?:\d{,3}))"
+    r"|"
     # IPv6 address
-    r'(?:\[(?P<ipv6>[0-9a-f:]+)\])'
-    r'|'
+    r"(?:\[(?P<ipv6>[0-9a-f:]+)\])"
+    r"|"
     # host name
-    r'(?:(?:[a-z\u00a1-\uffff0-9_]-?)*[a-z\u00a1-\uffff0-9]+)'
+    r"(?:(?:[a-z\u00a1-\uffff0-9_]-?)*[a-z\u00a1-\uffff0-9]+)"
     # domain name
-    r'(?:\.(?:[a-z\u00a1-\uffff0-9_]-?)*[a-z\u00a1-\uffff0-9]+)*'
+    r"(?:\.(?:[a-z\u00a1-\uffff0-9_]-?)*[a-z\u00a1-\uffff0-9]+)*"
     # TLD identifier
-    r'(?:\.(?P<tld>[a-z0-9\u00a1-\uffff]{2,}))'
-    r')'
+    r"(?:\.(?P<tld>[a-z0-9\u00a1-\uffff]{2,}))"
+    r")"
     # port number
-    r'(?::\d{2,5})?'
+    r"(?::\d{2,5})?"
     # resource path
-    r'(?:/\S*)?'
+    r"(?:/\S*)?"
     # query string
-    r'(?:\?\S*)?'
-    r'$',
-    re.UNICODE | re.IGNORECASE
+    r"(?:\?\S*)?"
+    r"$",
+    re.UNICODE | re.IGNORECASE,
 )
 
 
 class ValidationError(ValueError):
-    '''Raised when URL is invalid'''
+    """Raised when URL is invalid"""
+
     pass
 
 
@@ -74,59 +75,57 @@ def endpoint_for(endpoint, fallback_endpoint=None, **values):
         return None
 
 
-
 def idna(string):
-    return string.encode('idna').decode('utf8')
+    return string.encode("idna").decode("utf8")
 
 
-def validate(url, schemes=None, tlds=None, private=None, local=None,
-             credentials=None):
-    '''
+def validate(url, schemes=None, tlds=None, private=None, local=None, credentials=None):
+    """
     Validate and normalize an URL
 
     :param str url: The URL to validate and normalize
     :return str: The normalized URL
     :raises ValidationError: when URL does not validate
-    '''
+    """
     url = url.strip()
 
-    private = config_for(private, 'URLS_ALLOW_PRIVATE')
-    local = config_for(local, 'URLS_ALLOW_LOCAL')
-    credentials = config_for(credentials, 'URLS_ALLOW_CREDENTIALS')
-    schemes = config_for(schemes, 'URLS_ALLOWED_SCHEMES')
-    tlds = config_for(tlds, 'URLS_ALLOWED_TLDS')
+    private = config_for(private, "URLS_ALLOW_PRIVATE")
+    local = config_for(local, "URLS_ALLOW_LOCAL")
+    credentials = config_for(credentials, "URLS_ALLOW_CREDENTIALS")
+    schemes = config_for(schemes, "URLS_ALLOWED_SCHEMES")
+    tlds = config_for(tlds, "URLS_ALLOWED_TLDS")
 
     match = URL_REGEX.match(url)
     if not match:
         error(url)
 
-    scheme = (match.group('scheme') or '').lower()
+    scheme = (match.group("scheme") or "").lower()
     if scheme and scheme not in schemes:
-        error(url, _('Invalid scheme {0}, allowed schemes: {1}').format(scheme, ", ".join(schemes)))
+        error(url, _("Invalid scheme {0}, allowed schemes: {1}").format(scheme, ", ".join(schemes)))
 
-    if not credentials and match.group('credentials'):
-        error(url, _('Credentials in URL are not allowed'))
+    if not credentials and match.group("credentials"):
+        error(url, _("Credentials in URL are not allowed"))
 
-    tld = match.group('tld')
+    tld = match.group("tld")
     if tld and tld not in tlds and idna(tld) not in tlds:
-        error(url, _('Invalid TLD {0}').format(tld))
+        error(url, _("Invalid TLD {0}").format(tld))
 
-    ip = match.group('ipv6') or match.group('ipv4')
+    ip = match.group("ipv6") or match.group("ipv4")
     if ip:
         try:
             ip = IPAddress(ip)
         except AddrFormatError:
             error(url)
         if ip.is_multicast():
-            error(url, _('{0} is a multicast IP').format(ip))
+            error(url, _("{0} is a multicast IP").format(ip))
         elif not ip.is_loopback() and ip.is_hostmask() or ip.is_netmask():
-            error(url, _('{0} is a mask IP').format(ip))
+            error(url, _("{0} is a mask IP").format(ip))
 
     if not local:
-        if ip and ip.is_loopback() or match.group('localhost'):
-            error(url, _('is a local URL'))
+        if ip and ip.is_loopback() or match.group("localhost"):
+            error(url, _("is a local URL"))
 
     if not private and ip and ip.is_private():
-        error(url, _('is a private URL'))
+        error(url, _("is a private URL"))
 
     return url