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

udata/tests/forms/test_form_field.py

@@ -51,7 +51,7 @@ class FormFieldTest(TestCase):
 
     def test_with_one_valid_data(self):
         fake = Fake()
-        form = self.factory(MultiDict({'nested-name': 'John Doe'}))
+        form = self.factory(MultiDict({"nested-name": "John Doe"}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -59,11 +59,11 @@ class FormFieldTest(TestCase):
         form.populate_obj(fake)
 
         self.assertIsInstance(fake.nested, Nested)
-        self.assertEqual(fake.nested.name, 'John Doe')
+        self.assertEqual(fake.nested.name, "John Doe")
 
     def test_with_one_valid_json(self):
         fake = Fake()
-        form = self.factory({'nested': {'name': 'John Doe'}})
+        form = self.factory({"nested": {"name": "John Doe"}})
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -71,12 +71,12 @@ class FormFieldTest(TestCase):
         form.populate_obj(fake)
 
         self.assertIsInstance(fake.nested, Nested)
-        self.assertEqual(fake.nested.name, 'John Doe')
+        self.assertEqual(fake.nested.name, "John Doe")
 
     def test_with_initial_elements(self):
         fake = Fake.objects.create(nested=Nested(name=faker.name()))
         new_name = faker.name()
-        form = self.factory({'nested': {'name': new_name}}, fake)
+        form = self.factory({"nested": {"name": new_name}}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -90,7 +90,7 @@ class FormFieldTest(TestCase):
         fake = Fake.objects.create(nested=Nested(name=faker.name()))
         initial_id = fake.nested.id
         initial_name = fake.nested.name
-        form = self.factory({'name': faker.word()}, fake)
+        form = self.factory({"name": faker.word()}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -104,7 +104,7 @@ class FormFieldTest(TestCase):
         fake = Fake.objects.create(nested=Nested(name=faker.name()))
         initial_id = fake.nested.id
         new_name = faker.name()
-        form = self.factory({'nested': {'name': new_name}}, fake)
+        form = self.factory({"nested": {"name": new_name}}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -115,7 +115,7 @@ class FormFieldTest(TestCase):
         self.assertEqual(fake.nested.name, new_name)
 
     def test_create_with_non_submitted_elements(self):
-        form = self.factory({'name': faker.word()})
+        form = self.factory({"name": faker.word()})
 
         form.validate()
         self.assertEqual(form.errors, {})

udata/tests/forms/test_image_field.py

@@ -1,20 +1,19 @@
 import logging
 
-import pytest
-
 import flask_storage as fs
+import pytest
 
-from udata.mongo import db
+from udata.core.storages import tmp
 from udata.forms import Form
 from udata.forms.fields import ImageField
+from udata.mongo import db
 from udata.tests.helpers import data_path
-from udata.core.storages import tmp
 
 log = logging.getLogger(__name__)
 
 SIZES = [16, 32]
 
-storage = fs.Storage('test')
+storage = fs.Storage("test")
 
 
 class PostData(dict):
@@ -25,7 +24,7 @@ class PostData(dict):
         return value
 
 
-@pytest.mark.usefixtures('clean_db')
+@pytest.mark.usefixtures("clean_db")
 class ImageFieldTest:
     class D(db.Document):
         image = db.ImageField(fs=storage)
@@ -37,7 +36,7 @@ class ImageFieldTest:
 
     @pytest.fixture(autouse=True)
     def fs_root(self, instance_path, app):
-        app.config['FS_ROOT'] = str(instance_path / 'fs')
+        app.config["FS_ROOT"] = str(instance_path / "fs")
         fs.init_app(app, storage, tmp)
 
     def test_empty(self):
@@ -59,30 +58,34 @@ class ImageFieldTest:
 
     def test_with_image(self):
         doc = self.D()
-        with open(data_path('image.png'), 'rb') as img:
-            doc.image.save(img, 'image.jpg')
+        with open(data_path("image.png"), "rb") as img:
+            doc.image.save(img, "image.jpg")
         doc.save()
         form = self.F(None, obj=doc)
-        assert form.image.filename.data == 'image.jpg'
+        assert form.image.filename.data == "image.jpg"
         assert form.image.bbox.data is None
 
     def test_with_image_and_bbox(self):
         doc = self.D()
-        with open(data_path('image.png'), 'rb') as img:
-            doc.thumbnail.save(img, 'image.jpg', bbox=[10, 10, 100, 100])
+        with open(data_path("image.png"), "rb") as img:
+            doc.thumbnail.save(img, "image.jpg", bbox=[10, 10, 100, 100])
         doc.save()
         form = self.F(None, obj=doc)
-        assert form.thumbnail.filename.data == 'image.jpg'
+        assert form.thumbnail.filename.data == "image.jpg"
         assert form.thumbnail.bbox.data == [10, 10, 100, 100]
 
     def test_post_new(self):
-        tmp_filename = 'xyz/image.png'
-        with open(data_path('image.png'), 'rb') as img:
+        tmp_filename = "xyz/image.png"
+        with open(data_path("image.png"), "rb") as img:
             tmp_filename = tmp.save(img, tmp_filename)
 
-        form = self.F(PostData({
-            'image-filename': tmp_filename,
-        }))
+        form = self.F(
+            PostData(
+                {
+                    "image-filename": tmp_filename,
+                }
+            )
+        )
 
         assert form.image.filename.data == tmp_filename
         assert form.image.bbox.data is None
@@ -91,19 +94,23 @@ class ImageFieldTest:
         form.populate_obj(doc)
 
         assert doc.image.bbox is None
-        assert doc.image.filename.endswith('.png')
+        assert doc.image.filename.endswith(".png")
         assert doc.image.filename in storage
         assert tmp_filename not in tmp
 
     def test_post_new_with_crop(self):
-        tmp_filename = 'xyz/image.png'
-        with open(data_path('image.png'), 'rb') as img:
+        tmp_filename = "xyz/image.png"
+        with open(data_path("image.png"), "rb") as img:
             tmp_filename = tmp.save(img, tmp_filename)
 
-        form = self.F(PostData({
-            'thumbnail-filename': tmp_filename,
-            'thumbnail-bbox': '10,10,100,100',
-        }))
+        form = self.F(
+            PostData(
+                {
+                    "thumbnail-filename": tmp_filename,
+                    "thumbnail-bbox": "10,10,100,100",
+                }
+            )
+        )
 
         assert form.thumbnail.filename.data == tmp_filename
         assert form.thumbnail.bbox.data == [10, 10, 100, 100]
@@ -112,6 +119,6 @@ class ImageFieldTest:
         form.populate_obj(doc)
 
         assert doc.thumbnail.bbox == [10, 10, 100, 100]
-        assert doc.thumbnail.filename.endswith('.png')
+        assert doc.thumbnail.filename.endswith(".png")
         assert doc.thumbnail.filename in storage
         assert tmp_filename not in tmp

udata/tests/forms/test_model_field.py

@@ -1,15 +1,11 @@
 import pytest
-
 from werkzeug.datastructures import MultiDict
 
 from udata.forms import ModelForm, fields
 from udata.i18n import gettext as _
 from udata.mongo import db
 
-
-pytestmark = [
-    pytest.mark.usefixtures('clean_db')
-]
+pytestmark = [pytest.mark.usefixtures("clean_db")]
 
 
 class Target(db.Document):
@@ -31,44 +27,47 @@ class Generic:
 
     def test_error_with_inline_identifier(self):
         expected_target = Target.objects.create()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': str(expected_target.pk),
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": str(expected_target.pk),
+            }
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert form.errors['target'][0] == _('Expect both class and identifier')
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert form.errors["target"][0] == _("Expect both class and identifier")
 
     def test_error_with_identifier_only(self):
         expected_target = Target.objects.create()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {'id': str(expected_target.pk)},
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": {"id": str(expected_target.pk)},
+            }
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert form.errors['target'][0] == _('Expect both class and identifier')
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert form.errors["target"][0] == _("Expect both class and identifier")
 
     def test_error_with_unknown_model(self):
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Unknown',
-                'id': 42
-            },
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": {"class": "Unknown", "id": 42},
+            }
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert form.errors['target'][0] == 'Model "Unknown" does not exist'
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert form.errors["target"][0] == 'Model "Unknown" does not exist'
 
 
 class Explicit:
@@ -77,10 +76,14 @@ class Explicit:
     def test_with_inline_identifier_multidict(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form(MultiDict({
-            'name': 'test',
-            'target': str(expected_target.pk),
-        }))
+        form = self.form(
+            MultiDict(
+                {
+                    "name": "test",
+                    "target": str(expected_target.pk),
+                }
+            )
+        )
 
         form.validate()
         assert form.errors == {}
@@ -93,10 +96,14 @@ class Explicit:
     def test_with_identifier_only_multidict(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form(MultiDict({
-            'name': 'test',
-            'target-id': str(expected_target.pk),
-        }))
+        form = self.form(
+            MultiDict(
+                {
+                    "name": "test",
+                    "target-id": str(expected_target.pk),
+                }
+            )
+        )
 
         form.validate()
         assert form.errors == {}
@@ -109,10 +116,12 @@ class Explicit:
     def test_with_inline_identifier_json(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': str(expected_target.pk),
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": str(expected_target.pk),
+            }
+        )
 
         form.validate()
         assert form.errors == {}
@@ -125,10 +134,12 @@ class Explicit:
     def test_with_identifier_only_json(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {'id': str(expected_target.pk)},
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": {"id": str(expected_target.pk)},
+            }
+        )
 
         form.validate()
         assert form.errors == {}
@@ -140,71 +151,79 @@ class Explicit:
 
     def test_error_with_class_mismatch(self):
         expected_target = Target.objects.create()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Wrong',
-                'id': str(expected_target.pk)
-            },
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": {"class": "Wrong", "id": str(expected_target.pk)},
+            }
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert form.errors['target'][0] == _('Expect a "Target" class but "Wrong" was found')
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert form.errors["target"][0] == _('Expect a "Target" class but "Wrong" was found')
 
 
 class Required:
     required = True
 
     def test_not_provided(self):
-        form = self.form.from_json({'name': 'test'})
+        form = self.form.from_json({"name": "test"})
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert 'requis' in form.errors['target'][0]
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert "requis" in form.errors["target"][0]
 
     def test_none(self):
-        form = self.form.from_json({
-            'name': 'test',
-            'target': None,
-        })
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": None,
+            }
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert 'requis' in form.errors['target'][0]
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert "requis" in form.errors["target"][0]
 
     def test_with_initial_object_none(self):
         model = self.model(target=Target.objects.create())
 
-        form = self.form.from_json({
-            'name': 'test',
-            'target': None,
-        }, model)
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": None,
+            },
+            model,
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert 'requis' in form.errors['target'][0]
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert "requis" in form.errors["target"][0]
 
 
 class Optionnal:
-    '''Optional ModelField specific tests'''
+    """Optional ModelField specific tests"""
+
     required = False
 
     def test_with_initial_object_none(self):
         model = self.model(target=Target.objects.create())
 
-        form = self.form.from_json({
-            'name': 'test',
-            'target': None,
-        }, model)
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": None,
+            },
+            model,
+        )
 
         form.validate()
         assert form.errors == {}
@@ -236,11 +255,11 @@ class CommonMixin:
     def test_with_valid_multidict(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form(MultiDict({
-            'name': 'test',
-            'target-class': 'Target',
-            'target-id': str(expected_target.pk)
-        }))
+        form = self.form(
+            MultiDict(
+                {"name": "test", "target-class": "Target", "target-id": str(expected_target.pk)}
+            )
+        )
 
         form.validate()
         assert form.errors == {}
@@ -253,13 +272,9 @@ class CommonMixin:
     def test_with_valid_json(self):
         expected_target = Target.objects.create()
         model = self.model()
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Target',
-                'id': str(expected_target.pk)
-            }
-        })
+        form = self.form.from_json(
+            {"name": "test", "target": {"class": "Target", "id": str(expected_target.pk)}}
+        )
 
         form.validate()
         assert form.errors == {}
@@ -274,13 +289,9 @@ class CommonMixin:
         expected_target = Target.objects.create()
         model = self.model(target=initial_target)
 
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Target',
-                'id': str(expected_target.pk)
-            }
-        }, model)
+        form = self.form.from_json(
+            {"name": "test", "target": {"class": "Target", "id": str(expected_target.pk)}}, model
+        )
 
         form.validate()
         assert form.errors == {}
@@ -294,7 +305,7 @@ class CommonMixin:
         expected_target = Target.objects.create()
         model = self.model(target=expected_target)
 
-        form = self.form.from_json({'name': 'test'}, model)
+        form = self.form.from_json({"name": "test"}, model)
 
         form.validate()
         assert form.errors == {}
@@ -305,46 +316,46 @@ class CommonMixin:
         assert model.target == expected_target
 
     def test_multidict_errors(self):
-        form = self.form(MultiDict({
-            'name': 'test',
-            'target-class': 'Target',
-        }))
+        form = self.form(
+            MultiDict(
+                {
+                    "name": "test",
+                    "target-class": "Target",
+                }
+            )
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
         # assert 'Unsupported identifier' in form.errors['target'][0]
-        assert form.errors['target'][0] == _('Missing "id" field')
+        assert form.errors["target"][0] == _('Missing "id" field')
 
     def test_json_errors(self):
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Target',
+        form = self.form.from_json(
+            {
+                "name": "test",
+                "target": {
+                    "class": "Target",
+                },
             }
-        })
+        )
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert form.errors['target'][0] == _('Missing "id" field')
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert form.errors["target"][0] == _('Missing "id" field')
 
     def test_bad_id(self):
-        form = self.form.from_json({
-            'name': 'test',
-            'target': {
-                'class': 'Target',
-                'id': 'wrong'
-            }
-        })
+        form = self.form.from_json({"name": "test", "target": {"class": "Target", "id": "wrong"}})
 
         form.validate()
 
-        assert 'target' in form.errors
-        assert len(form.errors['target']) == 1
-        assert 'Unsupported identifier' in form.errors['target'][0]
+        assert "target" in form.errors
+        assert len(form.errors["target"]) == 1
+        assert "Unsupported identifier" in form.errors["target"][0]
 
 
 class Optionnal_GenericReference_Test(Generic, Optionnal, CommonMixin):

udata/tests/forms/test_model_list_field.py

@@ -36,7 +36,7 @@ class ModelListFieldTest(TestCase):
     def test_with_one_valid_data(self):
         nested = Nested.objects.create(name=faker.name())
         fake = Fake()
-        form = FakeForm(MultiDict({'nested': str(nested.id)}))
+        form = FakeForm(MultiDict({"nested": str(nested.id)}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -51,7 +51,7 @@ class ModelListFieldTest(TestCase):
         nesteds = [Nested.objects.create(name=faker.name()) for _ in range(3)]
         ids = [str(n.id) for n in nesteds]
         fake = Fake()
-        form = FakeForm(MultiDict({'nested': ','.join(ids)}))
+        form = FakeForm(MultiDict({"nested": ",".join(ids)}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -65,7 +65,7 @@ class ModelListFieldTest(TestCase):
     def test_with_one_valid_json_id(self):
         nested = Nested.objects.create(name=faker.name())
         fake = Fake()
-        form = FakeForm.from_json({'nested': [str(nested.id)]})
+        form = FakeForm.from_json({"nested": [str(nested.id)]})
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -79,7 +79,7 @@ class ModelListFieldTest(TestCase):
     def test_with_one_valid_json_object(self):
         nested = Nested.objects.create(name=faker.name())
         fake = Fake()
-        form = FakeForm.from_json({'nested': [{'id': str(nested.id)}]})
+        form = FakeForm.from_json({"nested": [{"id": str(nested.id)}]})
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -94,7 +94,7 @@ class ModelListFieldTest(TestCase):
         nested = [Nested.objects.create(name=faker.name()) for _ in range(3)]
         ids = [str(n.id) for n in nested]
         fake = Fake()
-        form = FakeForm.from_json({'nested': ids})
+        form = FakeForm.from_json({"nested": ids})
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -107,9 +107,9 @@ class ModelListFieldTest(TestCase):
 
     def test_with_multiple_valid_json_object(self):
         nested = [Nested.objects.create(name=faker.name()) for _ in range(3)]
-        ids = [{'id': str(n.id)} for n in nested]
+        ids = [{"id": str(n.id)} for n in nested]
         fake = Fake()
-        form = FakeForm.from_json({'nested': ids})
+        form = FakeForm.from_json({"nested": ids})
 
         form.validate()
         self.assertEqual(form.errors, {})