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

udata/tests/test_utils.py

@@ -1,14 +1,22 @@
 from datetime import date, datetime
 
 from udata.utils import (
-    get_by, daterange_start, daterange_end, to_bool, to_iso, to_iso_date,
-    to_iso_datetime, recursive_get, safe_unicode, to_naive_datetime
+    daterange_end,
+    daterange_start,
+    get_by,
+    recursive_get,
+    safe_unicode,
+    to_bool,
+    to_iso,
+    to_iso_date,
+    to_iso_datetime,
+    to_naive_datetime,
 )
 
 TEST_LIST = [
-    {'name': 'aaa', 'other': 'bbb'},
-    {'name': 'bbb', 'another': 'ddd'},
-    {'name': 'ccc', 'other': 'bbb'},
+    {"name": "aaa", "other": "bbb"},
+    {"name": "bbb", "another": "ddd"},
+    {"name": "ccc", "other": "bbb"},
 ]
 
 
@@ -19,34 +27,34 @@ class ObjDict(object):
 
 class GetByFieldTest:
     def test_find_dict(self):
-        '''get_by() should find a dictionnary in list'''
-        result = get_by(TEST_LIST, 'name', 'bbb')
-        assert result == {'name': 'bbb', 'another': 'ddd'}
+        """get_by() should find a dictionnary in list"""
+        result = get_by(TEST_LIST, "name", "bbb")
+        assert result == {"name": "bbb", "another": "ddd"}
 
     def test_find_object(self):
-        '''get_by() should find an object in list'''
+        """get_by() should find an object in list"""
         obj_lst = [ObjDict(d) for d in TEST_LIST]
-        result = get_by(obj_lst, 'name', 'bbb')
-        assert result.name == 'bbb'
-        assert result.another == 'ddd'
+        result = get_by(obj_lst, "name", "bbb")
+        assert result.name == "bbb"
+        assert result.another == "ddd"
 
     def test_not_found(self):
-        '''get_by() should return None if not found'''
-        assert get_by(TEST_LIST, 'name', 'not-found') is None
+        """get_by() should return None if not found"""
+        assert get_by(TEST_LIST, "name", "not-found") is None
 
     def test_attribute_not_found(self):
-        '''get_by() should not fail if an object don't have the given attr'''
-        assert get_by(TEST_LIST, 'inexistant', 'value') is None
+        """get_by() should not fail if an object don't have the given attr"""
+        assert get_by(TEST_LIST, "inexistant", "value") is None
 
 
 class DateRangeTest:
     def test_parse_daterange_start_empty(self):
         assert daterange_start(None) is None
-        assert daterange_start('') is None
+        assert daterange_start("") is None
 
     def test_parse_daterange_end_empty(self):
         assert daterange_end(None) is None
-        assert daterange_end('') is None
+        assert daterange_end("") is None
 
     def test_parse_daterange_start_date(self):
         today = date.today()
@@ -65,37 +73,37 @@ class DateRangeTest:
         assert daterange_end(now) == now.date()
 
     def test_parse_daterange_start_full_iso(self):
-        assert daterange_start('1984-06-07T00:00:00+00:00') == date(1984, 6, 7)
+        assert daterange_start("1984-06-07T00:00:00+00:00") == date(1984, 6, 7)
 
     def test_parse_daterange_end_full_iso(self):
-        assert daterange_end('1984-06-07T00:00:00+00:00') == date(1984, 6, 7)
+        assert daterange_end("1984-06-07T00:00:00+00:00") == date(1984, 6, 7)
 
     def test_parse_daterange_start_full(self):
-        assert daterange_start('1984-06-07') == date(1984, 6, 7)
+        assert daterange_start("1984-06-07") == date(1984, 6, 7)
 
     def test_parse_daterange_end_full(self):
-        assert daterange_end('1984-06-07') == date(1984, 6, 7)
+        assert daterange_end("1984-06-07") == date(1984, 6, 7)
 
     def test_parse_daterange_start_month(self):
-        assert daterange_start('1984-06') == date(1984, 6, 1)
+        assert daterange_start("1984-06") == date(1984, 6, 1)
 
     def test_parse_daterange_end_month(self):
-        assert daterange_end('1984-06') == date(1984, 6, 30)
-        assert daterange_end('1984-07') == date(1984, 7, 31)
+        assert daterange_end("1984-06") == date(1984, 6, 30)
+        assert daterange_end("1984-07") == date(1984, 7, 31)
 
     def test_parse_daterange_end_month_february(self):
-        assert daterange_end('1984-02') == date(1984, 2, 29)
-        assert daterange_end('1985-02') == date(1985, 2, 28)
+        assert daterange_end("1984-02") == date(1984, 2, 29)
+        assert daterange_end("1985-02") == date(1985, 2, 28)
 
     def test_parse_daterange_start_year(self):
-        assert daterange_start('1984') == date(1984, 1, 1)
+        assert daterange_start("1984") == date(1984, 1, 1)
 
     def test_parse_daterange_end_year(self):
-        assert daterange_end('1984') == date(1984, 12, 31)
+        assert daterange_end("1984") == date(1984, 12, 31)
 
     def test_parse_before_1900(self):
-        assert daterange_start('1860') == date(1860, 1, 1)
-        assert daterange_end('1860') == date(1860, 12, 31)
+        assert daterange_start("1860") == date(1860, 1, 1)
+        assert daterange_end("1860") == date(1860, 12, 31)
 
 
 class ToBoolTest:
@@ -104,15 +112,15 @@ class ToBoolTest:
         assert to_bool(False) is False
 
     def test_string_values(self):
-        assert to_bool('True') is True
-        assert to_bool('true') is True
-        assert to_bool('False') is False
-        assert to_bool('false') is False
-        assert to_bool('bla') is False
-        assert to_bool('T') is True
-        assert to_bool('F') is False
-        assert to_bool('t') is True
-        assert to_bool('f') is False
+        assert to_bool("True") is True
+        assert to_bool("true") is True
+        assert to_bool("False") is False
+        assert to_bool("false") is False
+        assert to_bool("bla") is False
+        assert to_bool("T") is True
+        assert to_bool("F") is False
+        assert to_bool("t") is True
+        assert to_bool("f") is False
 
     def test_int_values(self):
         assert to_bool(0) is False
@@ -126,114 +134,114 @@ class ToIsoTest:
         assert to_iso_date(None) is None
 
     def test_to_iso_date_with_datetime(self):
-        assert to_iso_date(datetime(1984, 2, 29, 1, 2, 3)) == '1984-02-29'
+        assert to_iso_date(datetime(1984, 2, 29, 1, 2, 3)) == "1984-02-29"
 
     def test_to_iso_date_with_date(self):
-        assert to_iso_date(date(1984, 2, 29)) == '1984-02-29'
+        assert to_iso_date(date(1984, 2, 29)) == "1984-02-29"
 
     def test_to_iso_date_before_1900(self):
-        assert to_iso_date(date(1884, 2, 29)) == '1884-02-29'
+        assert to_iso_date(date(1884, 2, 29)) == "1884-02-29"
 
     def test_to_iso_datetime_emtpy(self):
         assert to_iso_datetime(None) is None
 
     def test_to_iso_datetime_with_datetime(self):
         result = to_iso_datetime(datetime(1984, 2, 29, 1, 2, 3))
-        assert result == '1984-02-29T01:02:03'
+        assert result == "1984-02-29T01:02:03"
 
     def test_to_iso_datetime_with_date(self):
-        assert to_iso_datetime(date(1984, 2, 29)) == '1984-02-29T00:00:00'
+        assert to_iso_datetime(date(1984, 2, 29)) == "1984-02-29T00:00:00"
 
     def test_to_iso_datetime_before_1900(self):
-        assert to_iso_datetime(date(1884, 2, 29)) == '1884-02-29T00:00:00'
+        assert to_iso_datetime(date(1884, 2, 29)) == "1884-02-29T00:00:00"
 
     def test_to_iso_datetime_before_1000(self):
-        assert to_iso_datetime(date(908, 2, 29)) == '0908-02-29T00:00:00'
+        assert to_iso_datetime(date(908, 2, 29)) == "0908-02-29T00:00:00"
 
     def test_to_iso_emtpy(self):
         assert to_iso(None) is None
 
     def test_to_iso_with_datetime(self):
-        assert to_iso(datetime(1984, 2, 29, 1, 2, 3)) == '1984-02-29T01:02:03'
+        assert to_iso(datetime(1984, 2, 29, 1, 2, 3)) == "1984-02-29T01:02:03"
 
     def test_to_iso_with_date(self):
-        assert to_iso(date(1984, 2, 29)) == '1984-02-29'
+        assert to_iso(date(1984, 2, 29)) == "1984-02-29"
 
 
 class RecursiveGetTest:
     def test_get_root_attribute(self):
         class Tester(object):
-            attr = 'value'
+            attr = "value"
 
         tester = Tester()
-        assert recursive_get(tester, 'attr') == 'value'
+        assert recursive_get(tester, "attr") == "value"
 
     def test_get_root_key(self):
-        tester = {'key': 'value'}
-        assert recursive_get(tester, 'key') == 'value'
+        tester = {"key": "value"}
+        assert recursive_get(tester, "key") == "value"
 
     def test_get_nested_attribute(self):
         class Nested(object):
-            attr = 'value'
+            attr = "value"
 
         class Tester(object):
             def __init__(self):
                 self.nested = Nested()
 
         tester = Tester()
-        assert recursive_get(tester, 'nested.attr') == 'value'
+        assert recursive_get(tester, "nested.attr") == "value"
 
     def test_get_nested_key(self):
-        tester = {'nested': {'key': 'value'}}
-        assert recursive_get(tester, 'nested.key') == 'value'
+        tester = {"nested": {"key": "value"}}
+        assert recursive_get(tester, "nested.key") == "value"
 
     def test_attr_not_found(self):
         class Tester(object):
             pass
 
         tester = Tester()
-        assert recursive_get(tester, 'attr') is None
+        assert recursive_get(tester, "attr") is None
 
     def test_key_not_found(self):
-        tester = {'key': 'value'}
-        assert recursive_get(tester, 'not-found') is None
+        tester = {"key": "value"}
+        assert recursive_get(tester, "not-found") is None
 
     def test_nested_attribute_not_found(self):
         class Nested(object):
-            attr = 'value'
+            attr = "value"
 
         class Tester(object):
             def __init__(self):
                 self.nested = Nested()
 
         tester = Tester()
-        assert recursive_get(tester, 'nested.not_found') is None
+        assert recursive_get(tester, "nested.not_found") is None
 
     def test_nested_key_not_found(self):
-        tester = {'nested': {'key': 'value'}}
-        assert recursive_get(tester, 'nested.not_found') is None
+        tester = {"nested": {"key": "value"}}
+        assert recursive_get(tester, "nested.not_found") is None
 
     def test_get_on_none(self):
-        assert recursive_get(None, 'attr') is None
+        assert recursive_get(None, "attr") is None
 
     def test_get_key_none(self):
-        tester = {'key': 'value'}
+        tester = {"key": "value"}
         assert recursive_get(tester, None) is None
-        assert recursive_get(tester, '') is None
+        assert recursive_get(tester, "") is None
 
 
 class SafeUnicodeTest(object):
     def test_unicode_stays_unicode(self):
-        assert safe_unicode('ééé') == 'ééé'
+        assert safe_unicode("ééé") == "ééé"
 
     def test_bytes_is_decoded(self):
-        assert safe_unicode(b'xxx') == 'xxx'
+        assert safe_unicode(b"xxx") == "xxx"
 
     def test_object_to_string(self):
-        assert safe_unicode({}) == '{}'
+        assert safe_unicode({}) == "{}"
 
     def test_unicode_to_string(self):
-        assert safe_unicode(ValueError('é')) == 'é'
+        assert safe_unicode(ValueError("é")) == "é"
 
 
 class AwareDateTest:

udata/tests/user/test_user_rdf.py

@@ -1,13 +1,12 @@
 from flask import url_for
-
-from rdflib import URIRef, Literal, BNode
-from rdflib.namespace import RDF, FOAF, RDFS
+from rdflib import BNode, Literal, URIRef
+from rdflib.namespace import FOAF, RDF, RDFS
 from rdflib.resource import Resource as RdfResource
 
 from udata import api
-from udata.tests import TestCase, DBTestMixin
 from udata.core.user.factories import UserFactory
 from udata.core.user.rdf import user_to_rdf
+from udata.tests import DBTestMixin, TestCase
 from udata.utils import faker
 
 
@@ -33,9 +32,7 @@ class UserToRdfTest(DBTestMixin, TestCase):
 
     def test_all_fields(self):
         user = UserFactory(website=faker.uri())
-        user_url = url_for('api.user',
-                           user=user.id,
-                           _external=True)
+        user_url = url_for("api.user", user=user.id, _external=True)
         u = user_to_rdf(user)
         g = u.graph
 
@@ -48,5 +45,4 @@ class UserToRdfTest(DBTestMixin, TestCase):
         self.assertEqual(u.identifier.toPython(), user_url)
         self.assertEqual(u.value(FOAF.name), Literal(user.fullname))
         self.assertEqual(u.value(RDFS.label), Literal(user.fullname))
-        self.assertEqual(u.value(FOAF.homepage).identifier,
-                         URIRef(user.website))
+        self.assertEqual(u.value(FOAF.homepage).identifier, URIRef(user.website))

udata/tests/workers/test_jobs_commands.py

@@ -1,4 +1,5 @@
 import logging
+
 import pytest
 
 from udata.core.jobs.commands import job_label
@@ -7,7 +8,7 @@ from udata.tasks import job
 
 log = logging.getLogger(__name__)
 
-JOB_NAME = 'fake-job'
+JOB_NAME = "fake-job"
 
 
 @job(JOB_NAME)
@@ -15,33 +16,33 @@ def do_nothing(self, *args, **kwargs):
     pass
 
 
-@job('not-scheduled')
+@job("not-scheduled")
 def not_scheduled(self):
     pass
 
 
 @pytest.fixture
 def job_run(mocker):
-    return mocker.patch.object(do_nothing, 'run')
+    return mocker.patch.object(do_nothing, "run")
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class JobsCommandsTest:
     def test_list_jobs(self, cli):
-        result = cli('job list')
+        result = cli("job list")
         assert JOB_NAME in result.output
 
     def test_run_job(self, cli, job_run):
-        cli('job run fake-job')
+        cli("job run fake-job")
         job_run.assert_called()
 
     def test_delay_job(self, cli, job_run):
-        cli('job run -d fake-job')
+        cli("job run -d fake-job")
         job_run.assert_called()
 
     def test_run_job_kwargs(self, cli, job_run):
-        cli('job run fake-job arg key=value')
-        job_run.assert_called_with('arg', key='value')
+        cli("job run fake-job arg key=value")
+        job_run.assert_called_with("arg", key="value")
 
     def test_schedule_job(self, cli):
         cli('job schedule "0 1 2 3 sunday" fake-job')
@@ -52,59 +53,58 @@ class JobsCommandsTest:
         task = tasks[0]
         assert task.args == []
         assert task.kwargs == {}
-        assert task.crontab.minute == '0'
-        assert task.crontab.hour == '1'
-        assert task.crontab.day_of_month == '2'
-        assert task.crontab.month_of_year == '3'
-        assert task.crontab.day_of_week == 'sunday'
+        assert task.crontab.minute == "0"
+        assert task.crontab.hour == "1"
+        assert task.crontab.day_of_month == "2"
+        assert task.crontab.month_of_year == "3"
+        assert task.crontab.day_of_week == "sunday"
         assert task.enabled
-        assert task.name == 'Job {0}'.format(JOB_NAME)
+        assert task.name == "Job {0}".format(JOB_NAME)
 
     def test_schedule_job_with_parameters(self, cli):
-        cli('job schedule "0 1 2 3 sunday" fake-job '
-            'arg0 arg1 key1=value1 key0=value0')
+        cli('job schedule "0 1 2 3 sunday" fake-job ' "arg0 arg1 key1=value1 key0=value0")
 
         tasks = PeriodicTask.objects(task=JOB_NAME)
         assert len(tasks) == 1
 
         task = tasks[0]
-        assert task.args == ['arg0', 'arg1']  # Arguments order is preserved
-        assert task.kwargs == {'key0': 'value0', 'key1': 'value1'}
-        assert task.crontab.minute == '0'
-        assert task.crontab.hour == '1'
-        assert task.crontab.day_of_month == '2'
-        assert task.crontab.month_of_year == '3'
-        assert task.crontab.day_of_week == 'sunday'
+        assert task.args == ["arg0", "arg1"]  # Arguments order is preserved
+        assert task.kwargs == {"key0": "value0", "key1": "value1"}
+        assert task.crontab.minute == "0"
+        assert task.crontab.hour == "1"
+        assert task.crontab.day_of_month == "2"
+        assert task.crontab.month_of_year == "3"
+        assert task.crontab.day_of_week == "sunday"
         assert task.enabled
         # kwargs are sorted
-        expected = 'Job {0}(arg0, arg1, key0=value0, key1=value1)'
+        expected = "Job {0}(arg0, arg1, key0=value0, key1=value1)"
         assert task.name == expected.format(JOB_NAME)
 
     def test_scheduled_jobs(self, cli):
         tasks = [
             PeriodicTask.objects.create(
                 task=JOB_NAME,
-                name='job-1',
-                description='I\'m a scheduled job',
+                name="job-1",
+                description="I'm a scheduled job",
                 enabled=True,
-                crontab=PeriodicTask.Crontab.parse('0 0 0 0 0'),
+                crontab=PeriodicTask.Crontab.parse("0 0 0 0 0"),
             ),
             PeriodicTask.objects.create(
                 task=JOB_NAME,
-                name='job-2',
-                description='I\'m a scheduled job',
+                name="job-2",
+                description="I'm a scheduled job",
                 enabled=True,
-                args=['arg'],
-                kwargs={'key': 'value'},
-                crontab=PeriodicTask.Crontab.parse('0 0 0 0 0'),
-            )
+                args=["arg"],
+                kwargs={"key": "value"},
+                crontab=PeriodicTask.Crontab.parse("0 0 0 0 0"),
+            ),
         ]
-        result = cli('job scheduled')
+        result = cli("job scheduled")
 
-        filtered = [l for l in result.output.splitlines() if 'Tip' not in l]
+        filtered = [l for l in result.output.splitlines() if "Tip" not in l]
         assert len(filtered) == len(tasks)
 
-        assert 'not-scheduled' not in result.output
+        assert "not-scheduled" not in result.output
         for task in tasks:
             label = job_label(task.task, task.args, task.kwargs)
             assert label in result.output
@@ -114,39 +114,38 @@ class JobsCommandsTest:
     def test_unschedule_job(self, cli):
         PeriodicTask.objects.create(
             task=JOB_NAME,
-            name='job',
-            description='I\'m a scheduled job',
+            name="job",
+            description="I'm a scheduled job",
             enabled=True,
-            crontab=PeriodicTask.Crontab.parse('0 0 0 0 0'),
+            crontab=PeriodicTask.Crontab.parse("0 0 0 0 0"),
         )
-        cli('job unschedule {0}'.format(JOB_NAME))
+        cli("job unschedule {0}".format(JOB_NAME))
 
         assert len(PeriodicTask.objects(task=JOB_NAME)) == 0
 
     def test_unschedule_job_with_parameters(self, cli):
         PeriodicTask.objects.create(
             task=JOB_NAME,
-            name='job',
-            description='I\'m a scheduled job',
+            name="job",
+            description="I'm a scheduled job",
             enabled=True,
-            args=['arg'],
-            kwargs={'key': 'value'},
-            crontab=PeriodicTask.Crontab.parse('0 0 0 0 0'),
+            args=["arg"],
+            kwargs={"key": "value"},
+            crontab=PeriodicTask.Crontab.parse("0 0 0 0 0"),
         )
-        cli('job unschedule {0} arg key=value'.format(JOB_NAME))
+        cli("job unschedule {0} arg key=value".format(JOB_NAME))
 
         assert len(PeriodicTask.objects(task=JOB_NAME)) == 0
 
     def test_unschedule_job_different_parameters(self, cli):
         PeriodicTask.objects.create(
             task=JOB_NAME,
-            name='job',
-            description='I\'m a scheduled job',
+            name="job",
+            description="I'm a scheduled job",
             enabled=True,
-            crontab=PeriodicTask.Crontab.parse('0 0 0 0 0'),
+            crontab=PeriodicTask.Crontab.parse("0 0 0 0 0"),
         )
-        result = cli('job unschedule {0} arg'.format(JOB_NAME),
-                     check=False)
+        result = cli("job unschedule {0} arg".format(JOB_NAME), check=False)
 
         assert result.exit_code != 0
         assert len(PeriodicTask.objects(task=JOB_NAME)) == 1
@@ -161,10 +160,10 @@ class JobsCommandsTest:
         task = tasks[0]
         assert task.args == []
         assert task.kwargs == {}
-        assert task.crontab.minute == '1'
-        assert task.crontab.hour == '0'
-        assert task.crontab.day_of_month == '0'
-        assert task.crontab.month_of_year == '0'
-        assert task.crontab.day_of_week == '*'
+        assert task.crontab.minute == "1"
+        assert task.crontab.hour == "0"
+        assert task.crontab.day_of_month == "0"
+        assert task.crontab.month_of_year == "0"
+        assert task.crontab.day_of_week == "*"
         assert task.enabled
-        assert task.name == 'Job {0}'.format(JOB_NAME)
+        assert task.name == "Job {0}".format(JOB_NAME)

udata/tests/workers/test_tasks_routing.py

@@ -1,37 +1,32 @@
 import pytest
 
-from udata.tasks import celery, task, job
+from udata.tasks import celery, job, task
 from udata.utils import unique_string
 
-
 TASKS = [
-    ({}, 'default', None),
-    ({'queue': 'low'}, 'low', 'low.{name}'),
-    ({'queue': 'low', 'routing_key': 'key'}, 'low', 'key'),
-    ({'routing_key': 'key'}, None, 'key'),
-    ({'route': 'low.topic'}, 'low', 'low.topic'),
-    ({'route': 'low.topic', 'queue': 'q'}, 'low', 'low.topic'),
-    ({'route': 'low.topic', 'routing_key': 'rk'}, 'low', 'low.topic'),
+    ({}, "default", None),
+    ({"queue": "low"}, "low", "low.{name}"),
+    ({"queue": "low", "routing_key": "key"}, "low", "key"),
+    ({"routing_key": "key"}, None, "key"),
+    ({"route": "low.topic"}, "low", "low.topic"),
+    ({"route": "low.topic", "queue": "q"}, "low", "low.topic"),
+    ({"route": "low.topic", "routing_key": "rk"}, "low", "low.topic"),
 ]
 
 JOBS = [
-    ({}, 'low', 'low.{name}'),
-    ({'queue': 'high'}, 'high', 'high.{name}'),
-    ({'queue': 'high', 'routing_key': 'key'}, 'high', 'key'),
-    ({'routing_key': 'key'}, 'low', 'key'),
-    ({'route': 'high.topic'}, 'high', 'high.topic'),
-    ({'route': 'high.topic', 'queue': 'q'}, 'high', 'high.topic'),
-    ({'route': 'high.topic', 'routing_key': 'rk'}, 'high', 'high.topic'),
+    ({}, "low", "low.{name}"),
+    ({"queue": "high"}, "high", "high.{name}"),
+    ({"queue": "high", "routing_key": "key"}, "high", "key"),
+    ({"routing_key": "key"}, "low", "key"),
+    ({"route": "high.topic"}, "high", "high.topic"),
+    ({"route": "high.topic", "queue": "q"}, "high", "high.topic"),
+    ({"route": "high.topic", "routing_key": "rk"}, "high", "high.topic"),
 ]
 
 
 def idify(params):
-    '''Proper param display for easier debugging'''
-    return [
-        ', '.join('='.join(tup) for tup in row[0].items())
-        or 'none'
-        for row in params
-    ]
+    """Proper param display for easier debugging"""
+    return [", ".join("=".join(tup) for tup in row[0].items()) or "none" for row in params]
 
 
 def fake_task(*args, **kwargs):
@@ -40,7 +35,6 @@ def fake_task(*args, **kwargs):
 
 @pytest.fixture
 def route_to(app, mocker):
-
     def assertion(func, args, kwargs, queue, key=None):
         __tracebackhide__ = True
 
@@ -48,28 +42,28 @@ def route_to(app, mocker):
         router = celery.amqp.router
 
         # Celery instanciate only one task by name so we need unique names
-        suffix = unique_string().replace('-', '_')
-        fake_task.__name__ = 'task_{0}'.format(suffix)
+        suffix = unique_string().replace("-", "_")
+        fake_task.__name__ = "task_{0}".format(suffix)
         t = decorator(fake_task)
 
         options = t._get_exec_options()
 
         route = router.route(options, t.name, task_type=t)
         if queue:
-            assert route['queue'].name == queue, 'queue mismatch'
+            assert route["queue"].name == queue, "queue mismatch"
         if key:
             key = key.format(name=t.name)
-            assert route['routing_key'] == key, 'routing_key mismatch'
+            assert route["routing_key"] == key, "routing_key mismatch"
         return route
 
     return assertion
 
 
-@pytest.mark.parametrize('kwargs,queue,key', TASKS, ids=idify(TASKS))
+@pytest.mark.parametrize("kwargs,queue,key", TASKS, ids=idify(TASKS))
 def test_tasks_routing(route_to, kwargs, queue, key):
     route_to(task, [], kwargs, queue, key)
 
 
-@pytest.mark.parametrize('kwargs,queue,key', JOBS, ids=idify(JOBS))
+@pytest.mark.parametrize("kwargs,queue,key", JOBS, ids=idify(JOBS))
 def test_job_routing(route_to, kwargs, queue, key):
     route_to(job, [unique_string()], kwargs, queue, key)