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

udata/tests/frontend/test_csv.py

@@ -1,27 +1,22 @@
 import re
 from io import StringIO
-
-import factory
-
 from random import randint
 
+import factory
 from factory.mongoengine import MongoEngineFactory
+from flask import Blueprint, url_for
 
-from flask import url_for, Blueprint
-
-from udata.mongo import db
 from udata.frontend import csv
+from udata.mongo import db
 from udata.utils import faker
 
 from . import FrontTestCase
 
-
-RE_ATTACHMENT = re.compile(r'^attachment; filename=(?P<filename>.*)$')
-RE_FILENAME = re.compile(
-    r'^(?P<basename>.*)-\d{4}-\d{2}-\d{2}-\d{2}-\d{2}\.csv$')
+RE_ATTACHMENT = re.compile(r"^attachment; filename=(?P<filename>.*)$")
+RE_FILENAME = re.compile(r"^(?P<basename>.*)-\d{4}-\d{2}-\d{2}-\d{2}-\d{2}\.csv$")
 
 
-blueprint = Blueprint('testcsv', __name__)
+blueprint = Blueprint("testcsv", __name__)
 
 
 class NestedFake(db.EmbeddedDocument):
@@ -39,12 +34,12 @@ class Fake(db.Document):
     metrics = db.DictField()
 
     __metrics_keys__ = [
-        'fake-metric-int',
-        'fake-metric-float',
+        "fake-metric-int",
+        "fake-metric-float",
     ]
 
     def __str__(self):
-        return 'fake'
+        return "fake"
 
     def get_metrics(self):
         return self.metrics
@@ -64,57 +59,56 @@ class FakeFactory(MongoEngineFactory):
 
     title = factory.LazyAttribute(lambda o: faker.sentence())
     description = factory.LazyAttribute(lambda o: faker.paragraph())
-    tags = factory.LazyAttribute(
-        lambda o: [faker.word() for _ in range(1, randint(1, 4))])
+    tags = factory.LazyAttribute(lambda o: [faker.word() for _ in range(1, randint(1, 4))])
     sub = factory.SubFactory(NestedFactory)
 
 
 class NestedAdapter(csv.NestedAdapter):
-    attribute = 'nested'
+    attribute = "nested"
     fields = (
-        'title',
-        'description',
+        "title",
+        "description",
     )
     nested_fields = (
-        'key',
-        ('alias', 'value'),
+        "key",
+        ("alias", "value"),
     )
 
 
-@blueprint.route('/adapter.csv')
+@blueprint.route("/adapter.csv")
 def from_adapter():
     cls = csv.get_adapter(Fake)
     adapter = cls(Fake.objects)
     return csv.stream(adapter)
 
 
-@blueprint.route('/list.csv')
+@blueprint.route("/list.csv")
 def from_list():
     return csv.stream(list(Fake.objects))
 
 
-@blueprint.route('/queryset.csv')
+@blueprint.route("/queryset.csv")
 def from_queryset():
     qs = Fake.objects
     assert isinstance(qs, db.BaseQuerySet)
     return csv.stream(qs)
 
 
-@blueprint.route('/nested.csv')
+@blueprint.route("/nested.csv")
 def from_nested():
     qs = Fake.objects
     return csv.stream(NestedAdapter(qs))
 
 
-@blueprint.route('/with-basename.csv')
+@blueprint.route("/with-basename.csv")
 def with_basename():
     cls = csv.get_adapter(Fake)
     adapter = cls(Fake.objects)
-    return csv.stream(adapter, 'test')
+    return csv.stream(adapter, "test")
 
 
 class CsvTest(FrontTestCase):
-    modules = ['admin']
+    modules = ["admin"]
 
     def create_app(self):
         app = super(CsvTest, self).create_app()
@@ -124,13 +118,13 @@ class CsvTest(FrontTestCase):
     def test_adapter_fields_as_list(self):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = ['title', 'description']
+            fields = ["title", "description"]
 
         objects = FakeFactory.build_batch(3)
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description'])
+        self.assertEqual(header, ["title", "description"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -142,13 +136,13 @@ class CsvTest(FrontTestCase):
     def test_adapter_fields_as_list_with_nested(self):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = ['title', 'description', 'sub.key']
+            fields = ["title", "description", "sub.key"]
 
         objects = FakeFactory.build_batch(3)
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description', 'sub.key'])
+        self.assertEqual(header, ["title", "description", "sub.key"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -162,17 +156,17 @@ class CsvTest(FrontTestCase):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
             fields = (
-                'title',
-                'description',
-                ('tags', lambda o: ','.join(o.tags)),
-                ('alias', 'title'),
+                "title",
+                "description",
+                ("tags", lambda o: ",".join(o.tags)),
+                ("alias", "title"),
             )
 
         objects = FakeFactory.build_batch(3)
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description', 'tags', 'alias'])
+        self.assertEqual(header, ["title", "description", "tags", "alias"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -180,26 +174,22 @@ class CsvTest(FrontTestCase):
             self.assertEqual(len(row), len(header))
             self.assertEqual(row[0], obj.title)
             self.assertEqual(row[1], obj.description)
-            self.assertEqual(row[2], ','.join(obj.tags))
+            self.assertEqual(row[2], ",".join(obj.tags))
             self.assertEqual(row[3], obj.title)
 
     def test_adapter_fields_with_method(self):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = (
-                'title',
-                'description',
-                'tags'
-            )
+            fields = ("title", "description", "tags")
 
             def field_tags(self, obj):
-                return ','.join(obj.tags)
+                return ",".join(obj.tags)
 
         objects = FakeFactory.build_batch(3)
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description', 'tags'])
+        self.assertEqual(header, ["title", "description", "tags"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -207,27 +197,25 @@ class CsvTest(FrontTestCase):
             self.assertEqual(len(row), len(header))
             self.assertEqual(row[0], obj.title)
             self.assertEqual(row[1], obj.description)
-            self.assertEqual(row[2], ','.join(obj.tags))
+            self.assertEqual(row[2], ",".join(obj.tags))
 
     def test_adapter_fields_with_dyanmic_fields(self):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = (
-                'title',
-            )
+            fields = ("title",)
 
             def dynamic_fields(self):
                 return (
-                    'description',
-                    ('alias', 'title'),
-                    ('tags', lambda o: ','.join(o.tags)),
+                    "description",
+                    ("alias", "title"),
+                    ("tags", lambda o: ",".join(o.tags)),
                 )
 
         objects = FakeFactory.build_batch(3)
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description', 'alias', 'tags'])
+        self.assertEqual(header, ["title", "description", "alias", "tags"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -236,15 +224,14 @@ class CsvTest(FrontTestCase):
             self.assertEqual(row[0], obj.title)
             self.assertEqual(row[1], obj.description)
             self.assertEqual(row[2], obj.title)
-            self.assertEqual(row[3], ','.join(obj.tags))
+            self.assertEqual(row[3], ",".join(obj.tags))
 
     def test_metric_fields(self):
         expected = {
-            'metric.fake-metric-int': 5,
-            'metric.fake-metric-float': 0.5,
+            "metric.fake-metric-int": 5,
+            "metric.fake-metric-float": 0.5,
         }
-        fake = FakeFactory(
-            metrics={'fake-metric-int': 5, 'fake-metric-float': 0.5})
+        fake = FakeFactory(metrics={"fake-metric-int": 5, "fake-metric-float": 0.5})
 
         fields = csv.metric_fields(Fake)
         self.assertEqual(len(fields), len(expected))
@@ -255,13 +242,13 @@ class CsvTest(FrontTestCase):
     def test_unicode(self):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = ['title', 'description']
+            fields = ["title", "description"]
 
-        objects = FakeFactory.build_batch(3, description='é\xe9')
+        objects = FakeFactory.build_batch(3, description="é\xe9")
         adapter = Adapter(objects)
 
         header = adapter.header()
-        self.assertEqual(header, ['title', 'description'])
+        self.assertEqual(header, ["title", "description"])
 
         rows = list(adapter.rows())
         self.assertEqual(len(rows), len(objects))
@@ -279,18 +266,18 @@ class CsvTest(FrontTestCase):
     def assert_csv(self, endpoint, objects):
         @csv.adapter(Fake)
         class Adapter(csv.Adapter):
-            fields = ['title', 'description']
+            fields = ["title", "description"]
 
         response = self.get(url_for(endpoint))
 
         self.assert200(response)
-        self.assertEqual(response.mimetype, 'text/csv')
-        self.assertEqual(response.charset, 'utf-8')
+        self.assertEqual(response.mimetype, "text/csv")
+        self.assertEqual(response.charset, "utf-8")
 
-        csvfile = StringIO(response.data.decode('utf8'))
+        csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
         header = next(reader)
-        self.assertEqual(header, ['title', 'description'])
+        self.assertEqual(header, ["title", "description"])
 
         rows = list(reader)
         self.assertEqual(len(rows), len(objects))
@@ -302,55 +289,53 @@ class CsvTest(FrontTestCase):
         return response
 
     def assert_filename(self, response, basename):
-        header = response.headers['Content-Disposition']
+        header = response.headers["Content-Disposition"]
         m = RE_ATTACHMENT.match(header)
-        self.assertIsNotNone(
-            m,
-            'Content-Disposition header should specify a filename attachment')
-        filename = m.group('filename')
+        self.assertIsNotNone(m, "Content-Disposition header should specify a filename attachment")
+        filename = m.group("filename")
         m = RE_FILENAME.match(filename)
-        self.assertIsNotNone(m, 'filename should have the right pattern')
-        self.assertEqual(m.group('basename'), basename)
+        self.assertIsNotNone(m, "filename should have the right pattern")
+        self.assertEqual(m.group("basename"), basename)
 
     def test_stream_from_adapter(self):
-        response = self.assert_stream_csv('testcsv.from_adapter')
-        self.assert_filename(response, 'export')
+        response = self.assert_stream_csv("testcsv.from_adapter")
+        self.assert_filename(response, "export")
 
     def test_stream_from_queryset(self):
-        response = self.assert_stream_csv('testcsv.from_queryset')
-        self.assert_filename(response, 'export')
+        response = self.assert_stream_csv("testcsv.from_queryset")
+        self.assert_filename(response, "export")
 
     def test_stream_from_list(self):
-        response = self.assert_stream_csv('testcsv.from_list')
-        self.assert_filename(response, 'export')
+        response = self.assert_stream_csv("testcsv.from_list")
+        self.assert_filename(response, "export")
 
     def test_stream_with_basename(self):
-        response = self.assert_stream_csv('testcsv.with_basename')
-        self.assert_filename(response, 'test')
+        response = self.assert_stream_csv("testcsv.with_basename")
+        self.assert_filename(response, "test")
 
     def test_empty_stream_from_adapter(self):
-        response = self.assert_empty_stream_csv('testcsv.from_adapter')
-        self.assert_filename(response, 'export')
+        response = self.assert_empty_stream_csv("testcsv.from_adapter")
+        self.assert_filename(response, "export")
 
     def test_empty_stream_from_queryset(self):
-        response = self.assert_empty_stream_csv('testcsv.from_queryset')
-        self.assert_filename(response, 'export')
+        response = self.assert_empty_stream_csv("testcsv.from_queryset")
+        self.assert_filename(response, "export")
 
     def test_stream_nested_from_adapter(self):
         fake = FakeFactory.build()
         for i in range(3):
             fake.nested.append(NestedFake(key=faker.word(), value=i))
         fake.save()
-        response = self.get(url_for('testcsv.from_nested'))
+        response = self.get(url_for("testcsv.from_nested"))
 
         self.assert200(response)
-        self.assertEqual(response.mimetype, 'text/csv')
-        self.assertEqual(response.charset, 'utf-8')
+        self.assertEqual(response.mimetype, "text/csv")
+        self.assertEqual(response.charset, "utf-8")
 
-        csvfile = StringIO(response.data.decode('utf8'))
+        csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
         header = next(reader)
-        self.assertEqual(header, ['title', 'description', 'key', 'alias'])
+        self.assertEqual(header, ["title", "description", "key", "alias"])
 
         rows = list(reader)
         self.assertEqual(len(rows), len(fake.nested))
@@ -362,17 +347,17 @@ class CsvTest(FrontTestCase):
             self.assertEqual(row[3], str(obj.value))
 
     def test_stream_unicode(self):
-        fake = FakeFactory(title='é\xe9')
-        response = self.get(url_for('testcsv.from_adapter'))
+        fake = FakeFactory(title="é\xe9")
+        response = self.get(url_for("testcsv.from_adapter"))
 
         self.assert200(response)
-        self.assertEqual(response.mimetype, 'text/csv')
-        self.assertEqual(response.charset, 'utf-8')
+        self.assertEqual(response.mimetype, "text/csv")
+        self.assertEqual(response.charset, "utf-8")
 
-        csvfile = StringIO(response.data.decode('utf8'))
+        csvfile = StringIO(response.data.decode("utf8"))
         reader = csv.get_reader(csvfile)
         header = next(reader)
-        self.assertEqual(header, ['title', 'description'])
+        self.assertEqual(header, ["title", "description"])
 
         row = next(reader)
         self.assertEqual(len(row), len(header))

udata/tests/frontend/test_hooks.py

@@ -1,93 +1,93 @@
 import pytest
-
 from flask import Blueprint, render_template_string, url_for
+
 from udata.frontend import template_hook
 from udata.tests.helpers import assert200
 
-bp = Blueprint('hooks_tests', __name__, url_prefix='/hooks_tests')
+bp = Blueprint("hooks_tests", __name__, url_prefix="/hooks_tests")
 
 
 @template_hook
 def single(ctx):
-    return 'single'
+    return "single"
 
 
 @template_hook
 def hello(ctx, name):
-    return 'Hello {}'.format(name)
+    return "Hello {}".format(name)
 
 
 @template_hook
 def kwargs(ctx, **kwargs):
-    return ', '.join(sorted('{0}={1}'.format(k, v) for k, v in kwargs.items()))
+    return ", ".join(sorted("{0}={1}".format(k, v) for k, v in kwargs.items()))
 
 
-@template_hook('multiple')
+@template_hook("multiple")
 def first(ctx):
-    return 'first'
+    return "first"
 
 
-@template_hook('multiple')
+@template_hook("multiple")
 def second(ctx):
-    return 'second'
+    return "second"
 
 
-@template_hook('conditionnal', when=lambda ctx: True)
+@template_hook("conditionnal", when=lambda ctx: True)
 def true(ctx):
-    return 'true'
+    return "true"
 
 
-@template_hook('conditionnal', when=lambda ctx: False)
+@template_hook("conditionnal", when=lambda ctx: False)
 def false(ctx):
-    return 'false'
+    return "false"
 
 
-@bp.route('/empty/render')
+@bp.route("/empty/render")
 def render_empty():
     return render_template_string('{{ hook("empty") }}')
 
 
-@bp.route('/empty/iter')
+@bp.route("/empty/iter")
 def iter_empty():
     return render_template_string('{% for w in hook("empty") %}<{{ w }}>{% endfor %}')
 
 
-@bp.route('/hello')
+@bp.route("/hello")
 def render_hello():
     return render_template_string('{{ hook("hello", "world") }}')
 
 
-@bp.route('/kwargs')
+@bp.route("/kwargs")
 def render_kwargs():
     return render_template_string('{{ hook("kwargs", key="value", other=42) }}')
 
 
-@bp.route('/single/render')
+@bp.route("/single/render")
 def render_single():
     return render_template_string('{{ hook("single") }}')
 
 
-@bp.route('/single/iter')
+@bp.route("/single/iter")
 def iter_single():
     return render_template_string('{% for w in hook("single") %}<{{ w }}>{% endfor %}')
 
 
-@bp.route('/multiple/render')
+@bp.route("/multiple/render")
 def render_multiple():
     return render_template_string('{{ hook("multiple") }}')
 
 
-@bp.route('/multiple/iter')
+@bp.route("/multiple/iter")
 def iter_multiple():
     return render_template_string('{% for w in hook("multiple") %}<{{ w }}>{% endfor %}')
 
 
-@bp.route('/conditionnal/render')
+@bp.route("/conditionnal/render")
 def render_conditionnal():
     return render_template_string('{{ hook("conditionnal") }}')
 
 
-@bp.route('/conditionnal/iter')
+@bp.route("/conditionnal/iter")
 def iter_conditionnal():
     return render_template_string('{% for w in hook("conditionnal") %}<{{ w }}>{% endfor %}')
 
@@ -101,51 +101,51 @@ def app(app):
 @pytest.mark.frontend
 class HooksTest:
     def test_empty_template_hook(self, client):
-        response = client.get(url_for('hooks_tests.render_empty'))
+        response = client.get(url_for("hooks_tests.render_empty"))
         assert200(response)
-        assert b'' == response.data
+        assert b"" == response.data
 
     def test_iter_empty_template_hook(self, client):
-        response = client.get(url_for('hooks_tests.iter_empty'))
+        response = client.get(url_for("hooks_tests.iter_empty"))
         assert200(response)
-        assert b'' == response.data
+        assert b"" == response.data
 
     def test_single_template_hook(self, client):
-        response = client.get(url_for('hooks_tests.render_single'))
+        response = client.get(url_for("hooks_tests.render_single"))
         assert200(response)
-        assert b'single' == response.data
+        assert b"single" == response.data
 
     def test_iter_single_template_hook(self, client):
-        response = client.get(url_for('hooks_tests.iter_single'))
+        response = client.get(url_for("hooks_tests.iter_single"))
         assert200(response)
-        assert b'<single>' == response.data
+        assert b"<single>" == response.data
 
     def test_multiple_template_hooks(self, client):
-        response = client.get(url_for('hooks_tests.render_multiple'))
+        response = client.get(url_for("hooks_tests.render_multiple"))
         assert200(response)
-        assert b'firstsecond' == response.data
+        assert b"firstsecond" == response.data
 
     def test_iter_multiple_template_hooks(self, client):
-        response = client.get(url_for('hooks_tests.iter_multiple'))
+        response = client.get(url_for("hooks_tests.iter_multiple"))
         assert200(response)
-        assert b'<first><second>' == response.data
+        assert b"<first><second>" == response.data
 
     def test_conditionnal_template_hooks(self, client):
-        response = client.get(url_for('hooks_tests.render_conditionnal'))
+        response = client.get(url_for("hooks_tests.render_conditionnal"))
         assert200(response)
-        assert b'true' == response.data
+        assert b"true" == response.data
 
     def test_iter_conditionnal_template_hooks(self, client):
-        response = client.get(url_for('hooks_tests.iter_conditionnal'))
+        response = client.get(url_for("hooks_tests.iter_conditionnal"))
         assert200(response)
-        assert b'<true>' == response.data
+        assert b"<true>" == response.data
 
     def test_arguments(self, client):
-        response = client.get(url_for('hooks_tests.render_hello'))
+        response = client.get(url_for("hooks_tests.render_hello"))
         assert200(response)
-        assert b'Hello world' == response.data
+        assert b"Hello world" == response.data
 
     def test_kwargs(self, client):
-        response = client.get(url_for('hooks_tests.render_kwargs'))
+        response = client.get(url_for("hooks_tests.render_kwargs"))
         assert200(response)
-        assert b'key=value, other=42' == response.data
+        assert b"key=value, other=42" == response.data