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

udata/tests/forms/test_current_user_field.py

@@ -1,15 +1,15 @@
 import datetime
-from bson import ObjectId
 
+from bson import ObjectId
 from werkzeug.datastructures import MultiDict
 
 from udata.auth import login_user
 from udata.auth.forms import ExtendedLoginForm, ExtendedRegisterForm
-from udata.core.user.factories import UserFactory, AdminFactory
+from udata.core.user.factories import AdminFactory, UserFactory
 from udata.forms import ModelForm, fields
 from udata.i18n import gettext as _
-from udata.models import db, User
-from udata.tests import TestCase, DBTestMixin
+from udata.models import User, db
+from udata.tests import DBTestMixin, TestCase
 from udata.tests.helpers import security_gettext
 
 
@@ -53,9 +53,7 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'owner': str(user.id)
-        }))
+        form = OwnableForm(MultiDict({"owner": str(user.id)}))
 
         self.assertEqual(form.owner.data, user)
 
@@ -73,15 +71,13 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'owner': str(other.id)
-        }))
+        form = OwnableForm(MultiDict({"owner": str(other.id)}))
 
         self.assertEqual(form.owner.data, other)
 
         form.validate()
-        self.assertIn('owner', form.errors)
-        self.assertEqual(len(form.errors['owner']), 1)
+        self.assertIn("owner", form.errors)
+        self.assertEqual(len(form.errors["owner"]), 1)
 
     def test_with_other_user_admin(self):
         Ownable, OwnableForm = self.factory()
@@ -90,9 +86,7 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
 
         login_user(admin)
 
-        form = OwnableForm(MultiDict({
-            'owner': str(user.id)
-        }))
+        form = OwnableForm(MultiDict({"owner": str(user.id)}))
 
         self.assertEqual(form.owner.data, user)
 
@@ -108,9 +102,7 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
         user = UserFactory()
         login_user(user)
 
-        form = OwnableForm.from_json({
-            'owner': str(user.id)
-        })
+        form = OwnableForm.from_json({"owner": str(user.id)})
 
         self.assertEqual(form.owner.data, user)
 
@@ -126,9 +118,7 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
         user = UserFactory()
         login_user(user)
 
-        form = OwnableForm.from_json({
-            'owner': None
-        })
+        form = OwnableForm.from_json({"owner": None})
 
         self.assertEqual(form.owner.data, user)
 
@@ -144,9 +134,7 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
         user = UserFactory()
         login_user(user)
 
-        form = OwnableForm.from_json({
-            'owner': {'id': str(user.id)}
-        })
+        form = OwnableForm.from_json({"owner": {"id": str(user.id)}})
 
         self.assertEqual(form.owner.data, user)
 
@@ -163,13 +151,11 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'owner': str('wrongwith12c')
-        }))
+        form = OwnableForm(MultiDict({"owner": str("wrongwith12c")}))
 
         form.validate()
-        self.assertIn('owner', form.errors)
-        self.assertEqual(len(form.errors['owner']), 1)
+        self.assertIn("owner", form.errors)
+        self.assertEqual(len(form.errors["owner"]), 1)
 
     def test_with_user_not_found(self):
         Ownable, OwnableForm = self.factory()
@@ -177,72 +163,59 @@ class CurrentUserFieldTest(TestCase, DBTestMixin):
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'owner': str(ObjectId())
-        }))
+        form = OwnableForm(MultiDict({"owner": str(ObjectId())}))
 
         form.validate()
-        self.assertIn('owner', form.errors)
-        self.assertEqual(len(form.errors['owner']), 1)
+        self.assertIn("owner", form.errors)
+        self.assertEqual(len(form.errors["owner"]), 1)
 
     def test_with_user_not_logged_found(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
 
-        form = OwnableForm(MultiDict({
-            'owner': str(user.id)
-        }))
+        form = OwnableForm(MultiDict({"owner": str(user.id)}))
 
         form.validate()
-        self.assertIn('owner', form.errors)
-        self.assertEqual(len(form.errors['owner']), 1)
+        self.assertIn("owner", form.errors)
+        self.assertEqual(len(form.errors["owner"]), 1)
 
     def test_password_rotation(self):
         today = datetime.datetime.utcnow()
         user = UserFactory(
-            password='password',
-            password_rotation_demanded=today,
-            confirmed_at=today
+            password="password", password_rotation_demanded=today, confirmed_at=today
         )
 
-        form = ExtendedLoginForm.from_json({
-            'email': user.email,
-            'password': 'password'
-        })
+        form = ExtendedLoginForm.from_json({"email": user.email, "password": "password"})
 
         form.validate()
 
-        self.assertIn(_('Password must be changed for security reasons'), form.errors['password'])
+        self.assertIn(_("Password must be changed for security reasons"), form.errors["password"])
 
     def test_user_without_password(self):
         user = UserFactory(password=None)
 
-        form = ExtendedLoginForm.from_json({
-            'email': user.email,
-            'password': ''
-        })
+        form = ExtendedLoginForm.from_json({"email": user.email, "password": ""})
 
         form.validate()
 
-        self.assertIn(security_gettext('Password not provided'), form.errors['password'])
+        self.assertIn(security_gettext("Password not provided"), form.errors["password"])
 
     def test_email_validation(self):
-        self.app.config['SECURITY_EMAIL_VALIDATOR_ARGS'] = None
-        form = ExtendedRegisterForm.from_json({
-            'email': 'a@test.notreal',
-            'password': 'passpass',
-            'password_confirm': 'passpass',
-            'first_name': 'azeaezr',
-            'last_name': 'azeaze',
-        })
+        self.app.config["SECURITY_EMAIL_VALIDATOR_ARGS"] = None
+        form = ExtendedRegisterForm.from_json(
+            {
+                "email": "a@test.notreal",
+                "password": "passpass",
+                "password_confirm": "passpass",
+                "first_name": "azeaezr",
+                "last_name": "azeaze",
+            }
+        )
         form.validate()
-        self.assertIn(security_gettext('Invalid email address'), form.errors['email'])
+        self.assertIn(security_gettext("Invalid email address"), form.errors["email"])
 
         today = datetime.datetime.utcnow()
-        user = UserFactory(email='b@fake.com', password='password', confirmed_at=today)
-        form = ExtendedLoginForm.from_json({
-            'email': user.email,
-            'password': 'password'
-        })
+        user = UserFactory(email="b@fake.com", password="password", confirmed_at=today)
+        form = ExtendedLoginForm.from_json({"email": user.email, "password": "password"})
         form.validate()
         assert not form.errors

udata/tests/forms/test_daterange_field.py

@@ -22,7 +22,7 @@ class DateRangeFieldTest(TestCase):
         Fake, FakeForm = self.factory()
 
         form = FakeForm()
-        self.assertEqual(form.daterange._value(), '')
+        self.assertEqual(form.daterange._value(), "")
         self.assertEqual(form.daterange.data, None)
 
         fake = Fake()
@@ -31,24 +31,21 @@ class DateRangeFieldTest(TestCase):
 
     def test_initial_values(self):
         Fake, FakeForm = self.factory()
-        dr = db.DateRange(start=date.today() - timedelta(days=1),
-                          end=date.today())
+        dr = db.DateRange(start=date.today() - timedelta(days=1), end=date.today())
 
         fake = Fake(daterange=dr)
         form = FakeForm(None, obj=fake)
-        expected = ' - '.join([to_iso_date(dr.start), to_iso_date(dr.end)])
+        expected = " - ".join([to_iso_date(dr.start), to_iso_date(dr.end)])
         self.assertEqual(form.daterange._value(), expected)
 
     def test_with_valid_dates(self):
         Fake, FakeForm = self.factory()
         start = date.today() - timedelta(days=1)
         end = date.today()
-        expected = ' - '.join([to_iso_date(start), to_iso_date(end)])
+        expected = " - ".join([to_iso_date(start), to_iso_date(end)])
 
         fake = Fake()
-        form = FakeForm(MultiDict({
-            'daterange': expected
-        }))
+        form = FakeForm(MultiDict({"daterange": expected}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -63,12 +60,14 @@ class DateRangeFieldTest(TestCase):
         end = date.today()
 
         fake = Fake()
-        form = FakeForm.from_json({
-            'daterange': {
-                'start': to_iso_date(start),
-                'end': to_iso_date(end),
+        form = FakeForm.from_json(
+            {
+                "daterange": {
+                    "start": to_iso_date(start),
+                    "end": to_iso_date(end),
+                }
             }
-        })
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -80,54 +79,47 @@ class DateRangeFieldTest(TestCase):
     def test_with_invalid_dates(self):
         Fake, FakeForm = self.factory()
 
-        form = FakeForm(MultiDict({
-            'daterange': 'XXX - ZZZ'
-        }))
+        form = FakeForm(MultiDict({"daterange": "XXX - ZZZ"}))
 
         form.validate()
-        self.assertIn('daterange', form.errors)
-        self.assertEqual(len(form.errors['daterange']), 1)
+        self.assertIn("daterange", form.errors)
+        self.assertEqual(len(form.errors["daterange"]), 1)
 
     def test_with_invalid_format(self):
         Fake, FakeForm = self.factory()
         start = date.today() - timedelta(days=1)
         end = date.today()
-        wrong = ' xx '.join([to_iso_date(start), to_iso_date(end)])
+        wrong = " xx ".join([to_iso_date(start), to_iso_date(end)])
 
-        form = FakeForm(MultiDict({
-            'daterange': wrong
-        }))
+        form = FakeForm(MultiDict({"daterange": wrong}))
 
         form.validate()
-        self.assertIn('daterange', form.errors)
-        self.assertEqual(len(form.errors['daterange']), 1)
+        self.assertIn("daterange", form.errors)
+        self.assertEqual(len(form.errors["daterange"]), 1)
 
     def test_with_invalid_dates_from_json(self):
         Fake, FakeForm = self.factory()
 
-        form = FakeForm.from_json({
-            'daterange': {
-                'start': 'XXX',
-                'end': 'ZZZ'
-            }
-        })
+        form = FakeForm.from_json({"daterange": {"start": "XXX", "end": "ZZZ"}})
 
         form.validate()
-        self.assertIn('daterange', form.errors)
-        self.assertEqual(len(form.errors['daterange']), 1)
+        self.assertIn("daterange", form.errors)
+        self.assertEqual(len(form.errors["daterange"]), 1)
 
     def test_with_invalid_json_format(self):
         Fake, FakeForm = self.factory()
         start = date.today() - timedelta(days=1)
         end = date.today()
 
-        form = FakeForm.from_json({
-            'daterange': {
-                'a': to_iso_date(start),
-                'b': to_iso_date(end),
+        form = FakeForm.from_json(
+            {
+                "daterange": {
+                    "a": to_iso_date(start),
+                    "b": to_iso_date(end),
+                }
             }
-        })
+        )
 
         form.validate()
-        self.assertIn('daterange', form.errors)
-        self.assertEqual(len(form.errors['daterange']), 1)
+        self.assertIn("daterange", form.errors)
+        self.assertEqual(len(form.errors["daterange"]), 1)

udata/tests/forms/test_dict_field.py

@@ -1,19 +1,15 @@
-import pytest
-
 from datetime import date, datetime
 
+import pytest
 from werkzeug.datastructures import MultiDict
 
-from udata.forms import fields, ModelForm
+from udata.forms import ModelForm, fields
 from udata.mongo import db
 
-pytestmark = [
-    pytest.mark.usefixtures('app')
-]
+pytestmark = [pytest.mark.usefixtures("app")]
 
 
 class DictFieldTest:
-
     def factory(self):
         class Fake(db.Document):
             raw = db.DictField()
@@ -40,15 +36,21 @@ class DictFieldTest:
         today = date.today()
 
         fake = Fake()
-        form = FakeForm(MultiDict({'raw': {
-            'integer': 42,
-            'float': 42.0,
-            'string': 'value',
-            'datetime': now,
-            'date': today,
-            'bool': True,
-            'dict': {'key': 'value'}
-        }}))
+        form = FakeForm(
+            MultiDict(
+                {
+                    "raw": {
+                        "integer": 42,
+                        "float": 42.0,
+                        "string": "value",
+                        "datetime": now,
+                        "date": today,
+                        "bool": True,
+                        "dict": {"key": "value"},
+                    }
+                }
+            )
+        )
 
         form.validate()
         assert form.errors == {}
@@ -56,20 +58,20 @@ class DictFieldTest:
         form.populate_obj(fake)
 
         assert fake.raw == {
-            'integer': 42,
-            'float': 42.0,
-            'string': 'value',
-            'datetime': now,
-            'date': today,
-            'bool': True,
-            'dict': {'key': 'value'}
+            "integer": 42,
+            "float": 42.0,
+            "string": "value",
+            "datetime": now,
+            "date": today,
+            "bool": True,
+            "dict": {"key": "value"},
         }
 
     def test_with_invalid_data(self):
         Fake, FakeForm = self.factory()
 
-        form = FakeForm(MultiDict({'raw': 42}))
+        form = FakeForm(MultiDict({"raw": 42}))
 
         form.validate()
-        assert 'raw' in form.errors
-        assert len(form.errors['raw']) == 1
+        assert "raw" in form.errors
+        assert len(form.errors["raw"]) == 1

udata/tests/forms/test_extras_fields.py

@@ -1,20 +1,16 @@
-import pytest
-
 from datetime import date, datetime
 from uuid import UUID
 
+import pytest
 from werkzeug.datastructures import MultiDict
 
-from udata.forms import fields, ModelForm
+from udata.forms import ModelForm, fields
 from udata.mongo import db
 
-pytestmark = [
-    pytest.mark.usefixtures('app')
-]
+pytestmark = [pytest.mark.usefixtures("app")]
 
 
 class ExtrasFieldTest:
-
     def factory(self):
         class Fake(db.Document):
             extras = db.ExtrasField()
@@ -41,19 +37,25 @@ class ExtrasFieldTest:
         today = date.today()
 
         fake = Fake()
-        form = FakeForm(MultiDict({'extras': {
-            'integer': 42,
-            'float': 42.0,
-            'string': 'value',
-            'datetime': now,
-            'date': today,
-            'bool': True,
-            'dict': {
-                'integer': 42,
-                'float': 42.0,
-                'string': 'value',
-            }
-        }}))
+        form = FakeForm(
+            MultiDict(
+                {
+                    "extras": {
+                        "integer": 42,
+                        "float": 42.0,
+                        "string": "value",
+                        "datetime": now,
+                        "date": today,
+                        "bool": True,
+                        "dict": {
+                            "integer": 42,
+                            "float": 42.0,
+                            "string": "value",
+                        },
+                    }
+                }
+            )
+        )
 
         form.validate()
         assert form.errors == {}
@@ -61,24 +63,24 @@ class ExtrasFieldTest:
         form.populate_obj(fake)
 
         assert fake.extras == {
-            'integer': 42,
-            'float': 42.0,
-            'string': 'value',
-            'datetime': now,
-            'date': today,
-            'bool': True,
-            'dict': {
-                'integer': 42,
-                'float': 42.0,
-                'string': 'value',
-            }
+            "integer": 42,
+            "float": 42.0,
+            "string": "value",
+            "datetime": now,
+            "date": today,
+            "bool": True,
+            "dict": {
+                "integer": 42,
+                "float": 42.0,
+                "string": "value",
+            },
         }
 
     def test_with_null_data(self):
         Fake, FakeForm = self.factory()
 
         fake = Fake()
-        form = FakeForm(MultiDict({'extras': None}))
+        form = FakeForm(MultiDict({"extras": None}))
 
         form.validate()
         assert form.errors == {}
@@ -89,77 +91,101 @@ class ExtrasFieldTest:
     def test_with_valid_registered_data(self):
         Fake, FakeForm = self.factory()
 
-        @Fake.extras('dict')
+        @Fake.extras("dict")
         class Custom(db.DictField):
             pass
 
         fake = Fake()
-        form = FakeForm(MultiDict({'extras': {
-            'dict': {
-                'integer': 42,
-                'float': 42.0,
-                'string': 'value',
-            }
-        }}))
+        form = FakeForm(
+            MultiDict(
+                {
+                    "extras": {
+                        "dict": {
+                            "integer": 42,
+                            "float": 42.0,
+                            "string": "value",
+                        }
+                    }
+                }
+            )
+        )
 
         form.validate()
         assert form.errors == {}
 
         form.populate_obj(fake)
         assert fake.extras == {
-            'dict': {
-                'integer': 42,
-                'float': 42.0,
-                'string': 'value',
+            "dict": {
+                "integer": 42,
+                "float": 42.0,
+                "string": "value",
             }
         }
 
-    @pytest.mark.parametrize('dbfield,value,type,expected', [
-        pytest.param(*p, id=p[0].__name__) for p in [
-            (db.DateTimeField, '2018-05-29T13:15:04.397603', datetime,
-                datetime(2018, 5, 29, 13, 15, 4, 397603)),
-            (db.DateField, '2018-05-29', date, date(2018, 5, 29)),
-            (db.BooleanField, 'true', bool, True),
-            (db.IntField, 42, int, 42),
-            (db.StringField, '42', str, '42'),
-            (db.FloatField, '42.0', float, 42.0),
-            (db.URLField, 'http://test.com', str, 'http://test.com'),
-            (db.UUIDField, 'e3b06d6d-90c0-4407-adc0-de81d327f181', UUID,
-                UUID('e3b06d6d-90c0-4407-adc0-de81d327f181')),
-    ]])
+    @pytest.mark.parametrize(
+        "dbfield,value,type,expected",
+        [
+            pytest.param(*p, id=p[0].__name__)
+            for p in [
+                (
+                    db.DateTimeField,
+                    "2018-05-29T13:15:04.397603",
+                    datetime,
+                    datetime(2018, 5, 29, 13, 15, 4, 397603),
+                ),
+                (db.DateField, "2018-05-29", date, date(2018, 5, 29)),
+                (db.BooleanField, "true", bool, True),
+                (db.IntField, 42, int, 42),
+                (db.StringField, "42", str, "42"),
+                (db.FloatField, "42.0", float, 42.0),
+                (db.URLField, "http://test.com", str, "http://test.com"),
+                (
+                    db.UUIDField,
+                    "e3b06d6d-90c0-4407-adc0-de81d327f181",
+                    UUID,
+                    UUID("e3b06d6d-90c0-4407-adc0-de81d327f181"),
+                ),
+            ]
+        ],
+    )
     def test_can_parse_registered_data(self, dbfield, value, type, expected):
         Fake, FakeForm = self.factory()
 
-        Fake.extras.register('my:extra', dbfield)
+        Fake.extras.register("my:extra", dbfield)
 
         fake = Fake()
-        form = FakeForm(MultiDict({'extras': {'my:extra': value}}))
+        form = FakeForm(MultiDict({"extras": {"my:extra": value}}))
 
         form.validate()
         assert form.errors == {}
 
         form.populate_obj(fake)
 
-        assert isinstance(fake.extras['my:extra'], type)
-        assert fake.extras['my:extra'] == expected
-
-    @pytest.mark.parametrize('dbfield,value', [
-        pytest.param(*p, id=p[0].__name__) for p in [
-            (db.DateTimeField, 'xxxx'),
-            (db.DateField, 'xxxx'),
-            (db.IntField, 'xxxx'),
-            (db.StringField, 42),
-            (db.FloatField, 'xxxx'),
-            (db.URLField, 'not-an-url'),
-            (db.UUIDField, 'not-a-uuid'),
-    ]])
+        assert isinstance(fake.extras["my:extra"], type)
+        assert fake.extras["my:extra"] == expected
+
+    @pytest.mark.parametrize(
+        "dbfield,value",
+        [
+            pytest.param(*p, id=p[0].__name__)
+            for p in [
+                (db.DateTimeField, "xxxx"),
+                (db.DateField, "xxxx"),
+                (db.IntField, "xxxx"),
+                (db.StringField, 42),
+                (db.FloatField, "xxxx"),
+                (db.URLField, "not-an-url"),
+                (db.UUIDField, "not-a-uuid"),
+            ]
+        ],
+    )
     def test_fail_bad_registered_data(self, dbfield, value):
         Fake, FakeForm = self.factory()
 
-        Fake.extras.register('my:extra', dbfield)
+        Fake.extras.register("my:extra", dbfield)
 
-        form = FakeForm(MultiDict({'extras': {'my:extra': value}}))
+        form = FakeForm(MultiDict({"extras": {"my:extra": value}}))
 
         form.validate()
-        assert 'extras' in form.errors
-        assert 'my:extra' in form.errors['extras']
+        assert "extras" in form.errors
+        assert "my:extra" in form.errors["extras"]