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

udata/tests/forms/test_nested_model_list_field.py

@@ -68,7 +68,7 @@ class NestedModelListFieldTest(TestCase):
 
     def test_with_one_valid_data(self):
         fake = Fake()
-        form = self.factory(MultiDict({'nested-0-name': 'John Doe'}))
+        form = self.factory(MultiDict({"nested-0-name": "John Doe"}))
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -77,11 +77,11 @@ class NestedModelListFieldTest(TestCase):
 
         self.assertEqual(len(fake.nested), 1)
         self.assertIsInstance(fake.nested[0], Nested)
-        self.assertEqual(fake.nested[0].name, 'John Doe')
+        self.assertEqual(fake.nested[0].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, {})
@@ -90,15 +90,19 @@ class NestedModelListFieldTest(TestCase):
 
         self.assertEqual(len(fake.nested), 1)
         self.assertIsInstance(fake.nested[0], Nested)
-        self.assertEqual(fake.nested[0].name, 'John Doe')
+        self.assertEqual(fake.nested[0].name, "John Doe")
 
     def test_with_multiple_valid_data(self):
         fake = Fake()
-        form = self.factory(MultiDict([
-            ('nested-0-name', faker.name()),
-            ('nested-1-name', faker.name()),
-            ('nested-2-name', faker.name()),
-        ]))
+        form = self.factory(
+            MultiDict(
+                [
+                    ("nested-0-name", faker.name()),
+                    ("nested-1-name", faker.name()),
+                    ("nested-2-name", faker.name()),
+                ]
+            )
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -111,11 +115,15 @@ class NestedModelListFieldTest(TestCase):
 
     def test_with_multiple_valid_json(self):
         fake = Fake()
-        form = self.factory({'nested': [
-            {'name': faker.name()},
-            {'name': faker.name()},
-            {'name': faker.name()},
-        ]})
+        form = self.factory(
+            {
+                "nested": [
+                    {"name": faker.name()},
+                    {"name": faker.name()},
+                    {"name": faker.name()},
+                ]
+            }
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -127,16 +135,23 @@ class NestedModelListFieldTest(TestCase):
             self.assertIsInstance(nested, Nested)
 
     def test_with_initial_elements(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+            ]
+        )
         order = [n.id for n in fake.nested]
-        form = self.factory({'nested': [
-            {'id': str(fake.nested[0].id)},
-            {'id': str(fake.nested[1].id)},
-            {'name': faker.name()},
-        ]}, fake)
+        form = self.factory(
+            {
+                "nested": [
+                    {"id": str(fake.nested[0].id)},
+                    {"id": str(fake.nested[1].id)},
+                    {"name": faker.name()},
+                ]
+            },
+            fake,
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -149,17 +164,19 @@ class NestedModelListFieldTest(TestCase):
         self.assertIsNotNone(fake.nested[2].id)
 
     def test_with_nested_initial_elements(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name(), sub=SubNested(name=faker.word())),
-            Nested(name=faker.name(), sub=SubNested(name=faker.word())),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name(), sub=SubNested(name=faker.word())),
+                Nested(name=faker.name(), sub=SubNested(name=faker.word())),
+            ]
+        )
         order = [n.id for n in fake.nested]
         data = [
-            {'id': str(fake.nested[0].id)},
-            {'id': str(fake.nested[1].id)},
-            {'name': faker.name(), 'sub': {'name': faker.name()}},
+            {"id": str(fake.nested[0].id)},
+            {"id": str(fake.nested[1].id)},
+            {"name": faker.name(), "sub": {"name": faker.name()}},
         ]
-        form = self.factory({'nested': data}, fake, sub=True)
+        form = self.factory({"nested": data}, fake, sub=True)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -173,19 +190,26 @@ class NestedModelListFieldTest(TestCase):
             self.assertIsNotNone(nested.sub)
             self.assertIsNotNone(nested.sub.name)
         self.assertIsNotNone(fake.nested[2].id)
-        self.assertEqual(fake.nested[2].sub.name, data[2]['sub']['name'])
+        self.assertEqual(fake.nested[2].sub.name, data[2]["sub"]["name"])
 
     def test_with_initial_elements_as_ids(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+            ]
+        )
         order = [n.id for n in fake.nested]
-        form = self.factory({'nested': [
-            str(fake.nested[0].id),
-            str(fake.nested[1].id),
-            {'name': faker.name()},
-        ]}, fake)
+        form = self.factory(
+            {
+                "nested": [
+                    str(fake.nested[0].id),
+                    str(fake.nested[1].id),
+                    {"name": faker.name()},
+                ]
+            },
+            fake,
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -198,12 +222,14 @@ class NestedModelListFieldTest(TestCase):
         self.assertIsNotNone(fake.nested[2].id)
 
     def test_with_non_submitted_initial_elements(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+            ]
+        )
         initial = [(n.id, n.name) for n in fake.nested]
-        form = self.factory({'name': faker.word()}, fake)
+        form = self.factory({"name": faker.word()}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -217,17 +243,24 @@ class NestedModelListFieldTest(TestCase):
             self.assertEqual(nested.name, name)
 
     def test_update_initial_elements(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+            ]
+        )
         initial = [n.id for n in fake.nested]
-        form = self.factory({'nested': [
-            {'id': str(fake.nested[0].id), 'name': faker.name()},
-            {'id': str(fake.nested[1].id), 'name': faker.name()},
-            {'name': faker.name()},
-        ]}, fake)
-        names = [n['name'] for n in form.data['nested']]
+        form = self.factory(
+            {
+                "nested": [
+                    {"id": str(fake.nested[0].id), "name": faker.name()},
+                    {"id": str(fake.nested[1].id), "name": faker.name()},
+                    {"name": faker.name()},
+                ]
+            },
+            fake,
+        )
+        names = [n["name"] for n in form.data["nested"]]
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -242,10 +275,15 @@ class NestedModelListFieldTest(TestCase):
         self.assertIsNotNone(fake.nested[2].id)
 
     def test_non_submitted_subnested(self):
-        form = self.factory({'nested': [
-            {'name': faker.name()},
-            {'name': faker.name(), 'sub': {'name': faker.name()}},
-        ]}, sub=True)
+        form = self.factory(
+            {
+                "nested": [
+                    {"name": faker.name()},
+                    {"name": faker.name(), "sub": {"name": faker.name()}},
+                ]
+            },
+            sub=True,
+        )
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -257,17 +295,17 @@ class NestedModelListFieldTest(TestCase):
         self.assertIsNotNone(fake.nested[1].sub)
 
     def test_reorder_initial_elements(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-            Nested(name=faker.name()),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+                Nested(name=faker.name()),
+            ]
+        )
         initial = [(n.id, n.name) for n in fake.nested]
         new_order = [1, 2, 3, 0]
-        form = self.factory({'nested': [
-            {'id': str(fake.nested[i].id)} for i in new_order
-        ]}, fake)
+        form = self.factory({"nested": [{"id": str(fake.nested[i].id)} for i in new_order]}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -281,18 +319,18 @@ class NestedModelListFieldTest(TestCase):
             self.assertEqual(nested.name, name)
 
     def test_reorder_initial_elements_with_raw(self):
-        fake = Fake.objects.create(nested=[
-            Nested(name=faker.name(), raw={'test': 0}),
-            Nested(name=faker.name(), raw={'test': 1}),
-            Nested(name=faker.name(), raw={'test': 2}),
-            Nested(name=faker.name(), raw={'test': 3}),
-        ])
+        fake = Fake.objects.create(
+            nested=[
+                Nested(name=faker.name(), raw={"test": 0}),
+                Nested(name=faker.name(), raw={"test": 1}),
+                Nested(name=faker.name(), raw={"test": 2}),
+                Nested(name=faker.name(), raw={"test": 3}),
+            ]
+        )
         initial = [(n.id, n.name) for n in fake.nested]
 
         new_order = [1, 2, 3, 0]
-        form = self.factory({'nested': [
-            {'id': str(fake.nested[i].id)} for i in new_order
-        ]}, fake)
+        form = self.factory({"nested": [{"id": str(fake.nested[i].id)} for i in new_order]}, fake)
 
         form.validate()
         self.assertEqual(form.errors, {})
@@ -304,4 +342,4 @@ class NestedModelListFieldTest(TestCase):
             id, name = initial[old_idx]
             self.assertEqual(nested.id, id)
             self.assertEqual(nested.name, name)
-            self.assertEqual(nested.raw['test'], old_idx)
+            self.assertEqual(nested.raw["test"], old_idx)

udata/tests/forms/test_publish_as_field.py

@@ -1,12 +1,11 @@
 from bson import ObjectId
-
 from werkzeug.datastructures import MultiDict
 
 from udata.auth import login_user
-from udata.core.user.factories import UserFactory, AdminFactory
 from udata.core.organization.factories import OrganizationFactory
+from udata.core.user.factories import AdminFactory, UserFactory
 from udata.forms import ModelForm, fields
-from udata.models import db, User, Organization, Member
+from udata.models import Member, Organization, User, db
 from udata.tests import TestCase
 
 
@@ -86,14 +85,12 @@ class PublishFieldTest(TestCase):
     def test_with_valid_organization(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'organization': str(org.id)
-        }))
+        form = OwnableForm(MultiDict({"organization": str(org.id)}))
 
         self.assertEqual(form.owner.data, user)
         self.assertEqual(form.organization.data, org)
@@ -112,15 +109,12 @@ class PublishFieldTest(TestCase):
     def test_organization_over_owner(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'owner': str(user.id),
-            'organization': str(org.id)
-        }))
+        form = OwnableForm(MultiDict({"owner": str(user.id), "organization": str(org.id)}))
 
         self.assertEqual(form.owner.data, user)
         self.assertEqual(form.organization.data, org)
@@ -139,14 +133,12 @@ class PublishFieldTest(TestCase):
     def test_with_valid_organization_from_json(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
 
         login_user(user)
 
-        form = OwnableForm.from_json({
-            'organization': str(org.id)
-        })
+        form = OwnableForm.from_json({"organization": str(org.id)})
 
         self.assertEqual(form.owner.data, user)
         self.assertEqual(form.organization.data, org)
@@ -165,14 +157,12 @@ class PublishFieldTest(TestCase):
     def test_with_organization_object_from_json(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
 
         login_user(user)
 
-        form = OwnableForm.from_json({
-            'organization': {'id': str(org.id)}
-        })
+        form = OwnableForm.from_json({"organization": {"id": str(org.id)}})
 
         self.assertEqual(form.organization.data, org)
 
@@ -187,36 +177,29 @@ class PublishFieldTest(TestCase):
     def test_with_invalid_data(self):
         Ownable, OwnableForm = self.factory()
 
-        form = OwnableForm(MultiDict({
-            'organization': str('wrongwith12c')
-        }))
+        form = OwnableForm(MultiDict({"organization": str("wrongwith12c")}))
 
         form.validate()
-        self.assertIn('organization', form.errors)
-        self.assertEqual(len(form.errors['organization']), 1)
+        self.assertIn("organization", form.errors)
+        self.assertEqual(len(form.errors["organization"]), 1)
 
     def test_with_organization_not_found(self):
         Ownable, OwnableForm = self.factory()
 
-        form = OwnableForm(MultiDict({
-            'organization': str(ObjectId())
-        }))
+        form = OwnableForm(MultiDict({"organization": str(ObjectId())}))
 
         form.validate()
-        self.assertIn('organization', form.errors)
-        self.assertEqual(len(form.errors['organization']), 1)
+        self.assertIn("organization", form.errors)
+        self.assertEqual(len(form.errors["organization"]), 1)
 
     def test_with_initial_and_both_member(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        org = OrganizationFactory(members=[Member(user=user, role='editor')])
-        neworg = OrganizationFactory(
-            members=[Member(user=user, role='editor')])
+        org = OrganizationFactory(members=[Member(user=user, role="editor")])
+        neworg = OrganizationFactory(members=[Member(user=user, role="editor")])
         ownable = Ownable(organization=org)
 
-        form = OwnableForm(MultiDict({
-            'organization': str(neworg.id)
-        }), obj=ownable)
+        form = OwnableForm(MultiDict({"organization": str(neworg.id)}), obj=ownable)
 
         self.assertEqual(form.organization.data, neworg)
 
@@ -231,65 +214,57 @@ class PublishFieldTest(TestCase):
     def test_with_initial_and_not_member(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        org = OrganizationFactory(members=[Member(user=user, role='editor')])
+        org = OrganizationFactory(members=[Member(user=user, role="editor")])
         neworg = OrganizationFactory()
         ownable = Ownable(organization=org)
 
-        form = OwnableForm(MultiDict({
-            'organization': str(neworg.id)
-        }), obj=ownable)
+        form = OwnableForm(MultiDict({"organization": str(neworg.id)}), obj=ownable)
 
         self.assertEqual(form.organization.data, neworg)
 
         login_user(user)
         form.validate()
-        self.assertIn('organization', form.errors)
-        self.assertEqual(len(form.errors['organization']), 1)
+        self.assertIn("organization", form.errors)
+        self.assertEqual(len(form.errors["organization"]), 1)
 
     def test_not_member(self):
         Ownable, OwnableForm = self.factory()
-        member = Member(user=UserFactory(), role='editor')
+        member = Member(user=UserFactory(), role="editor")
         org = OrganizationFactory(members=[member])
 
         login_user(UserFactory())
 
-        form = OwnableForm(MultiDict({
-            'organization': str(org.id)
-        }))
+        form = OwnableForm(MultiDict({"organization": str(org.id)}))
 
         self.assertEqual(form.organization.data, org)
 
         self.assertFalse(form.validate())
-        self.assertIn('organization', form.errors)
-        self.assertEqual(len(form.errors['organization']), 1)
+        self.assertIn("organization", form.errors)
+        self.assertEqual(len(form.errors["organization"]), 1)
 
     def test_no_user_logged_in_permission(self):
         Ownable, OwnableForm = self.factory()
-        member = Member(user=UserFactory(), role='editor')
+        member = Member(user=UserFactory(), role="editor")
         org = OrganizationFactory(members=[member])
 
-        form = OwnableForm(MultiDict({
-            'organization': str(org.id)
-        }))
+        form = OwnableForm(MultiDict({"organization": str(org.id)}))
 
         self.assertEqual(form.organization.data, org)
 
         self.assertFalse(form.validate())
-        self.assertIn('organization', form.errors)
-        self.assertEqual(len(form.errors['organization']), 1)
+        self.assertIn("organization", form.errors)
+        self.assertEqual(len(form.errors["organization"]), 1)
 
     def test_set_organization_if_permissions(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        member = Member(user=user, role='editor')
+        member = Member(user=user, role="editor")
         org = OrganizationFactory(members=[member])
         ownable = Ownable(owner=user)
 
         login_user(user)
 
-        form = OwnableForm(MultiDict({
-            'organization': str(org.id)
-        }), obj=ownable)
+        form = OwnableForm(MultiDict({"organization": str(org.id)}), obj=ownable)
 
         self.assertTrue(form.validate())
         self.assertEqual(form.errors, {})
@@ -306,9 +281,7 @@ class PublishFieldTest(TestCase):
 
         login_user(AdminFactory())
 
-        form = OwnableForm(MultiDict({
-            'owner': str(user.id)
-        }), obj=ownable)
+        form = OwnableForm(MultiDict({"owner": str(user.id)}), obj=ownable)
 
         self.assertEqual(form.owner.data, user)
         self.assertEqual(form.organization.data, org)
@@ -331,9 +304,7 @@ class PublishFieldTest(TestCase):
 
         login_user(AdminFactory())
 
-        form = OwnableForm(MultiDict({
-            'organization': str(org.id)
-        }), obj=ownable)
+        form = OwnableForm(MultiDict({"organization": str(org.id)}), obj=ownable)
 
         self.assertEqual(form.owner.data, user)
         self.assertEqual(form.organization.data, org)
@@ -351,7 +322,7 @@ class PublishFieldTest(TestCase):
     def test_with_initial_org_and_no_data_provided(self):
         Ownable, OwnableForm = self.factory()
         user = UserFactory()
-        org = OrganizationFactory(members=[Member(user=user, role='editor')])
+        org = OrganizationFactory(members=[Member(user=user, role="editor")])
         ownable = Ownable(organization=org)
 
         form = OwnableForm(MultiDict({}), obj=ownable)