1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
from django.forms.models import ModelForm, inlineformset_factory
from django.test import TestCase, skipUnlessDBFeature
from .models import Child, Parent, Poem, Poet, School
class DeletionTests(TestCase):
def test_deletion(self):
PoemFormSet = inlineformset_factory(
Poet, Poem, can_delete=True, fields="__all__"
)
poet = Poet.objects.create(name="test")
poem = poet.poem_set.create(name="test poem")
data = {
"poem_set-TOTAL_FORMS": "1",
"poem_set-INITIAL_FORMS": "1",
"poem_set-MAX_NUM_FORMS": "0",
"poem_set-0-id": str(poem.pk),
"poem_set-0-poet": str(poet.pk),
"poem_set-0-name": "test",
"poem_set-0-DELETE": "on",
}
formset = PoemFormSet(data, instance=poet)
formset.save()
self.assertTrue(formset.is_valid())
self.assertEqual(Poem.objects.count(), 0)
def test_add_form_deletion_when_invalid(self):
"""
Make sure that an add form that is filled out, but marked for deletion
doesn't cause validation errors.
"""
PoemFormSet = inlineformset_factory(
Poet, Poem, can_delete=True, fields="__all__"
)
poet = Poet.objects.create(name="test")
data = {
"poem_set-TOTAL_FORMS": "1",
"poem_set-INITIAL_FORMS": "0",
"poem_set-MAX_NUM_FORMS": "0",
"poem_set-0-id": "",
"poem_set-0-poem": "1",
"poem_set-0-name": "x" * 1000,
}
formset = PoemFormSet(data, instance=poet)
# Make sure this form doesn't pass validation.
self.assertIs(formset.is_valid(), False)
self.assertEqual(Poem.objects.count(), 0)
# Then make sure that it *does* pass validation and delete the object,
# even though the data isn't actually valid.
data["poem_set-0-DELETE"] = "on"
formset = PoemFormSet(data, instance=poet)
self.assertIs(formset.is_valid(), True)
formset.save()
self.assertEqual(Poem.objects.count(), 0)
def test_change_form_deletion_when_invalid(self):
"""
Make sure that a change form that is filled out, but marked for deletion
doesn't cause validation errors.
"""
PoemFormSet = inlineformset_factory(
Poet, Poem, can_delete=True, fields="__all__"
)
poet = Poet.objects.create(name="test")
poem = poet.poem_set.create(name="test poem")
data = {
"poem_set-TOTAL_FORMS": "1",
"poem_set-INITIAL_FORMS": "1",
"poem_set-MAX_NUM_FORMS": "0",
"poem_set-0-id": str(poem.id),
"poem_set-0-poem": str(poem.id),
"poem_set-0-name": "x" * 1000,
}
formset = PoemFormSet(data, instance=poet)
# Make sure this form doesn't pass validation.
self.assertIs(formset.is_valid(), False)
self.assertEqual(Poem.objects.count(), 1)
# Then make sure that it *does* pass validation and delete the object,
# even though the data isn't actually valid.
data["poem_set-0-DELETE"] = "on"
formset = PoemFormSet(data, instance=poet)
self.assertIs(formset.is_valid(), True)
formset.save()
self.assertEqual(Poem.objects.count(), 0)
def test_save_new(self):
"""
Make sure inlineformsets respect commit=False
regression for #10750
"""
# exclude some required field from the forms
ChildFormSet = inlineformset_factory(
School, Child, exclude=["father", "mother"]
)
school = School.objects.create(name="test")
mother = Parent.objects.create(name="mother")
father = Parent.objects.create(name="father")
data = {
"child_set-TOTAL_FORMS": "1",
"child_set-INITIAL_FORMS": "0",
"child_set-MAX_NUM_FORMS": "0",
"child_set-0-name": "child",
}
formset = ChildFormSet(data, instance=school)
self.assertIs(formset.is_valid(), True)
objects = formset.save(commit=False)
for obj in objects:
obj.mother = mother
obj.father = father
obj.save()
self.assertEqual(school.child_set.count(), 1)
class InlineFormsetFactoryTest(TestCase):
def test_inline_formset_factory(self):
"""
These should both work without a problem.
"""
inlineformset_factory(Parent, Child, fk_name="mother", fields="__all__")
inlineformset_factory(Parent, Child, fk_name="father", fields="__all__")
def test_exception_on_unspecified_foreign_key(self):
"""
Child has two ForeignKeys to Parent, so if we don't specify which one
to use for the inline formset, we should get an exception.
"""
msg = (
"'inline_formsets.Child' has more than one ForeignKey to "
"'inline_formsets.Parent'."
)
with self.assertRaisesMessage(ValueError, msg):
inlineformset_factory(Parent, Child)
def test_fk_name_not_foreign_key_field_from_child(self):
"""
If we specify fk_name, but it isn't a ForeignKey from the child model
to the parent model, we should get an exception.
"""
msg = "fk_name 'school' is not a ForeignKey to 'inline_formsets.Parent'."
with self.assertRaisesMessage(ValueError, msg):
inlineformset_factory(Parent, Child, fk_name="school")
def test_non_foreign_key_field(self):
"""
If the field specified in fk_name is not a ForeignKey, we should get an
exception.
"""
with self.assertRaisesMessage(
ValueError, "'inline_formsets.Child' has no field named 'test'."
):
inlineformset_factory(Parent, Child, fk_name="test")
def test_any_iterable_allowed_as_argument_to_exclude(self):
# Regression test for #9171.
inlineformset_factory(Parent, Child, exclude=["school"], fk_name="mother")
inlineformset_factory(Parent, Child, exclude=("school",), fk_name="mother")
@skipUnlessDBFeature("allows_auto_pk_0")
def test_zero_primary_key(self):
# Regression test for #21472
poet = Poet.objects.create(id=0, name="test")
poet.poem_set.create(name="test poem")
PoemFormSet = inlineformset_factory(Poet, Poem, fields="__all__", extra=0)
formset = PoemFormSet(None, instance=poet)
self.assertEqual(len(formset.forms), 1)
def test_unsaved_fk_validate_unique(self):
poet = Poet(name="unsaved")
PoemFormSet = inlineformset_factory(Poet, Poem, fields=["name"])
data = {
"poem_set-TOTAL_FORMS": "2",
"poem_set-INITIAL_FORMS": "0",
"poem_set-MAX_NUM_FORMS": "2",
"poem_set-0-name": "Poem",
"poem_set-1-name": "Poem",
}
formset = PoemFormSet(data, instance=poet)
self.assertFalse(formset.is_valid())
self.assertEqual(
formset.non_form_errors(), ["Please correct the duplicate data for name."]
)
def test_fk_not_duplicated_in_form_fields(self):
"""
A foreign key name isn't duplicated in form._meta fields (#21332).
"""
poet = Poet.objects.create(name="test")
poet.poem_set.create(name="first test poem")
poet.poem_set.create(name="second test poem")
poet.poem_set.create(name="third test poem")
PoemFormSet = inlineformset_factory(Poet, Poem, fields=("name",), extra=0)
formset = PoemFormSet(None, instance=poet)
self.assertEqual(len(formset.forms), 3)
self.assertEqual(["name", "poet"], PoemFormSet.form._meta.fields)
def test_fk_in_all_formset_forms(self):
"""
A foreign key field is in Meta for all forms in the formset (#26538).
"""
class PoemModelForm(ModelForm):
def __init__(self, *args, **kwargs):
assert "poet" in self._meta.fields
super().__init__(*args, **kwargs)
poet = Poet.objects.create(name="test")
poet.poem_set.create(name="first test poem")
poet.poem_set.create(name="second test poem")
PoemFormSet = inlineformset_factory(
Poet, Poem, form=PoemModelForm, fields=("name",), extra=0
)
formset = PoemFormSet(None, instance=poet)
formset.forms # Trigger form instantiation to run the assert above.
|
