mirror of
https://github.com/django/django.git
synced 2024-12-23 09:36:06 +00:00
a2e97abd81
When __len__() is called (e.g. when casting to list or tuple), the QuerySet is evaluated and the result cache populated. iterator() shouldn't be called on the QuerySet after that, as it would reset the result cache and trigger a second query.
288 lines
12 KiB
Python
288 lines
12 KiB
Python
import datetime
|
|
|
|
from django import forms
|
|
from django.core.validators import ValidationError
|
|
from django.forms.models import ModelChoiceIterator
|
|
from django.forms.widgets import CheckboxSelectMultiple
|
|
from django.template import Context, Template
|
|
from django.test import TestCase
|
|
|
|
from .models import Article, Author, Book, Category, Writer
|
|
|
|
|
|
class ModelChoiceFieldTests(TestCase):
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.c1 = Category.objects.create(name='Entertainment', slug='entertainment', url='entertainment')
|
|
cls.c2 = Category.objects.create(name='A test', slug='test', url='test')
|
|
cls.c3 = Category.objects.create(name='Third', slug='third-test', url='third')
|
|
|
|
def test_basics(self):
|
|
f = forms.ModelChoiceField(Category.objects.all())
|
|
self.assertEqual(list(f.choices), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'Entertainment'),
|
|
(self.c2.pk, 'A test'),
|
|
(self.c3.pk, 'Third'),
|
|
])
|
|
with self.assertRaises(ValidationError):
|
|
f.clean('')
|
|
with self.assertRaises(ValidationError):
|
|
f.clean(None)
|
|
with self.assertRaises(ValidationError):
|
|
f.clean(0)
|
|
|
|
# Invalid types that require TypeError to be caught.
|
|
with self.assertRaises(ValidationError):
|
|
f.clean([['fail']])
|
|
with self.assertRaises(ValidationError):
|
|
f.clean([{'foo': 'bar'}])
|
|
|
|
self.assertEqual(f.clean(self.c2.id).name, 'A test')
|
|
self.assertEqual(f.clean(self.c3.id).name, 'Third')
|
|
|
|
# Add a Category object *after* the ModelChoiceField has already been
|
|
# instantiated. This proves clean() checks the database during clean()
|
|
# rather than caching it at instantiation time.
|
|
c4 = Category.objects.create(name='Fourth', url='4th')
|
|
self.assertEqual(f.clean(c4.id).name, 'Fourth')
|
|
|
|
# Delete a Category object *after* the ModelChoiceField has already been
|
|
# instantiated. This proves clean() checks the database during clean()
|
|
# rather than caching it at instantiation time.
|
|
Category.objects.get(url='4th').delete()
|
|
msg = "['Select a valid choice. That choice is not one of the available choices.']"
|
|
with self.assertRaisesMessage(ValidationError, msg):
|
|
f.clean(c4.id)
|
|
|
|
def test_choices(self):
|
|
f = forms.ModelChoiceField(Category.objects.filter(pk=self.c1.id), required=False)
|
|
self.assertIsNone(f.clean(''))
|
|
self.assertEqual(f.clean(str(self.c1.id)).name, 'Entertainment')
|
|
with self.assertRaises(ValidationError):
|
|
f.clean('100')
|
|
|
|
# len() can be called on choices.
|
|
self.assertEqual(len(f.choices), 2)
|
|
|
|
# queryset can be changed after the field is created.
|
|
f.queryset = Category.objects.exclude(name='Third')
|
|
self.assertEqual(list(f.choices), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'Entertainment'),
|
|
(self.c2.pk, 'A test'),
|
|
])
|
|
self.assertEqual(f.clean(self.c2.id).name, 'A test')
|
|
with self.assertRaises(ValidationError):
|
|
f.clean(self.c3.id)
|
|
|
|
# Choices can be iterated repeatedly.
|
|
gen_one = list(f.choices)
|
|
gen_two = f.choices
|
|
self.assertEqual(gen_one[2], (self.c2.pk, 'A test'))
|
|
self.assertEqual(list(gen_two), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'Entertainment'),
|
|
(self.c2.pk, 'A test'),
|
|
])
|
|
|
|
# Overriding label_from_instance() to print custom labels.
|
|
f.queryset = Category.objects.all()
|
|
f.label_from_instance = lambda obj: 'category ' + str(obj)
|
|
self.assertEqual(list(f.choices), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'category Entertainment'),
|
|
(self.c2.pk, 'category A test'),
|
|
(self.c3.pk, 'category Third'),
|
|
])
|
|
|
|
def test_deepcopies_widget(self):
|
|
class ModelChoiceForm(forms.Form):
|
|
category = forms.ModelChoiceField(Category.objects.all())
|
|
|
|
form1 = ModelChoiceForm()
|
|
field1 = form1.fields['category']
|
|
# To allow the widget to change the queryset of field1.widget.choices
|
|
# without affecting other forms, the following must hold (#11183):
|
|
self.assertIsNot(field1, ModelChoiceForm.base_fields['category'])
|
|
self.assertIs(field1.widget.choices.field, field1)
|
|
|
|
def test_result_cache_not_shared(self):
|
|
class ModelChoiceForm(forms.Form):
|
|
category = forms.ModelChoiceField(Category.objects.all())
|
|
|
|
form1 = ModelChoiceForm()
|
|
self.assertCountEqual(form1.fields['category'].queryset, [self.c1, self.c2, self.c3])
|
|
form2 = ModelChoiceForm()
|
|
self.assertIsNone(form2.fields['category'].queryset._result_cache)
|
|
|
|
def test_queryset_none(self):
|
|
class ModelChoiceForm(forms.Form):
|
|
category = forms.ModelChoiceField(queryset=None)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.fields['category'].queryset = Category.objects.filter(slug__contains='test')
|
|
|
|
form = ModelChoiceForm()
|
|
self.assertCountEqual(form.fields['category'].queryset, [self.c2, self.c3])
|
|
|
|
def test_no_extra_query_when_accessing_attrs(self):
|
|
"""
|
|
ModelChoiceField with RadioSelect widget doesn't produce unnecessary
|
|
db queries when accessing its BoundField's attrs.
|
|
"""
|
|
class ModelChoiceForm(forms.Form):
|
|
category = forms.ModelChoiceField(Category.objects.all(), widget=forms.RadioSelect)
|
|
|
|
form = ModelChoiceForm()
|
|
field = form['category'] # BoundField
|
|
template = Template('{{ field.name }}{{ field }}{{ field.help_text }}')
|
|
with self.assertNumQueries(1):
|
|
template.render(Context({'field': field}))
|
|
|
|
def test_disabled_modelchoicefield(self):
|
|
class ModelChoiceForm(forms.ModelForm):
|
|
author = forms.ModelChoiceField(Author.objects.all(), disabled=True)
|
|
|
|
class Meta:
|
|
model = Book
|
|
fields = ['author']
|
|
|
|
book = Book.objects.create(author=Writer.objects.create(name='Test writer'))
|
|
form = ModelChoiceForm({}, instance=book)
|
|
self.assertEqual(
|
|
form.errors['author'],
|
|
['Select a valid choice. That choice is not one of the available choices.']
|
|
)
|
|
|
|
def test_disabled_modelchoicefield_has_changed(self):
|
|
field = forms.ModelChoiceField(Author.objects.all(), disabled=True)
|
|
self.assertIs(field.has_changed('x', 'y'), False)
|
|
|
|
def test_disabled_multiplemodelchoicefield(self):
|
|
class ArticleForm(forms.ModelForm):
|
|
categories = forms.ModelMultipleChoiceField(Category.objects.all(), required=False)
|
|
|
|
class Meta:
|
|
model = Article
|
|
fields = ['categories']
|
|
|
|
category1 = Category.objects.create(name='cat1')
|
|
category2 = Category.objects.create(name='cat2')
|
|
article = Article.objects.create(
|
|
pub_date=datetime.date(1988, 1, 4),
|
|
writer=Writer.objects.create(name='Test writer'),
|
|
)
|
|
article.categories.set([category1.pk])
|
|
|
|
form = ArticleForm(data={'categories': [category2.pk]}, instance=article)
|
|
self.assertEqual(form.errors, {})
|
|
self.assertEqual([x.pk for x in form.cleaned_data['categories']], [category2.pk])
|
|
# Disabled fields use the value from `instance` rather than `data`.
|
|
form = ArticleForm(data={'categories': [category2.pk]}, instance=article)
|
|
form.fields['categories'].disabled = True
|
|
self.assertEqual(form.errors, {})
|
|
self.assertEqual([x.pk for x in form.cleaned_data['categories']], [category1.pk])
|
|
|
|
def test_disabled_modelmultiplechoicefield_has_changed(self):
|
|
field = forms.ModelMultipleChoiceField(Author.objects.all(), disabled=True)
|
|
self.assertIs(field.has_changed('x', 'y'), False)
|
|
|
|
def test_overridable_choice_iterator(self):
|
|
"""
|
|
Iterator defaults to ModelChoiceIterator and can be overridden with
|
|
the iterator attribute on a ModelChoiceField subclass.
|
|
"""
|
|
field = forms.ModelChoiceField(Category.objects.all())
|
|
self.assertIsInstance(field.choices, ModelChoiceIterator)
|
|
|
|
class CustomModelChoiceIterator(ModelChoiceIterator):
|
|
pass
|
|
|
|
class CustomModelChoiceField(forms.ModelChoiceField):
|
|
iterator = CustomModelChoiceIterator
|
|
|
|
field = CustomModelChoiceField(Category.objects.all())
|
|
self.assertIsInstance(field.choices, CustomModelChoiceIterator)
|
|
|
|
def test_choice_iterator_passes_model_to_widget(self):
|
|
class CustomModelChoiceValue:
|
|
def __init__(self, value, obj):
|
|
self.value = value
|
|
self.obj = obj
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
class CustomModelChoiceIterator(ModelChoiceIterator):
|
|
def choice(self, obj):
|
|
value, label = super().choice(obj)
|
|
return CustomModelChoiceValue(value, obj), label
|
|
|
|
class CustomCheckboxSelectMultiple(CheckboxSelectMultiple):
|
|
def create_option(self, name, value, label, selected, index, subindex=None, attrs=None):
|
|
option = super().create_option(name, value, label, selected, index, subindex=None, attrs=None)
|
|
# Modify the HTML based on the object being rendered.
|
|
c = value.obj
|
|
option['attrs']['data-slug'] = c.slug
|
|
return option
|
|
|
|
class CustomModelMultipleChoiceField(forms.ModelMultipleChoiceField):
|
|
iterator = CustomModelChoiceIterator
|
|
widget = CustomCheckboxSelectMultiple
|
|
|
|
field = CustomModelMultipleChoiceField(Category.objects.all())
|
|
self.assertHTMLEqual(
|
|
field.widget.render('name', []),
|
|
'''<ul>
|
|
<li><label><input type="checkbox" name="name" value="%d" data-slug="entertainment">Entertainment</label></li>
|
|
<li><label><input type="checkbox" name="name" value="%d" data-slug="test">A test</label></li>
|
|
<li><label><input type="checkbox" name="name" value="%d" data-slug="third-test">Third</label></li>
|
|
</ul>''' % (self.c1.pk, self.c2.pk, self.c3.pk),
|
|
)
|
|
|
|
def test_choices_not_fetched_when_not_rendering(self):
|
|
with self.assertNumQueries(1):
|
|
field = forms.ModelChoiceField(Category.objects.order_by('-name'))
|
|
self.assertEqual('Entertainment', field.clean(self.c1.pk).name)
|
|
|
|
def test_queryset_manager(self):
|
|
f = forms.ModelChoiceField(Category.objects)
|
|
self.assertEqual(len(f.choices), 4)
|
|
self.assertEqual(list(f.choices), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'Entertainment'),
|
|
(self.c2.pk, 'A test'),
|
|
(self.c3.pk, 'Third'),
|
|
])
|
|
|
|
def test_queryset_result_cache_is_reused(self):
|
|
f = forms.ModelChoiceField(Category.objects.all())
|
|
with self.assertNumQueries(1):
|
|
# list() calls __len__() and __iter__(); no duplicate queries.
|
|
self.assertEqual(list(f.choices), [
|
|
('', '---------'),
|
|
(self.c1.pk, 'Entertainment'),
|
|
(self.c2.pk, 'A test'),
|
|
(self.c3.pk, 'Third'),
|
|
])
|
|
|
|
def test_num_queries(self):
|
|
"""
|
|
Widgets that render multiple subwidgets shouldn't make more than one
|
|
database query.
|
|
"""
|
|
categories = Category.objects.all()
|
|
|
|
class CategoriesForm(forms.Form):
|
|
radio = forms.ModelChoiceField(queryset=categories, widget=forms.RadioSelect)
|
|
checkbox = forms.ModelMultipleChoiceField(queryset=categories, widget=forms.CheckboxSelectMultiple)
|
|
|
|
template = Template(
|
|
'{% for widget in form.checkbox %}{{ widget }}{% endfor %}'
|
|
'{% for widget in form.radio %}{{ widget }}{% endfor %}'
|
|
)
|
|
with self.assertNumQueries(2):
|
|
template.render(Context({'form': CategoriesForm()}))
|