django/tests/modeladmin/test_checks.py

1596 lines
47 KiB
Python

from django import forms
from django.contrib import admin
from django.contrib.admin import BooleanFieldListFilter, SimpleListFilter
from django.contrib.admin.options import VERTICAL, ModelAdmin, TabularInline
from django.contrib.admin.sites import AdminSite
from django.core.checks import Error
from django.db.models import CASCADE, F, Field, ForeignKey, Model
from django.db.models.functions import Upper
from django.forms.models import BaseModelFormSet
from django.test import SimpleTestCase
from .models import Band, Song, User, ValidationTestInlineModel, ValidationTestModel
class CheckTestCase(SimpleTestCase):
def assertIsInvalid(
self,
model_admin,
model,
msg,
id=None,
hint=None,
invalid_obj=None,
admin_site=None,
):
if admin_site is None:
admin_site = AdminSite()
invalid_obj = invalid_obj or model_admin
admin_obj = model_admin(model, admin_site)
self.assertEqual(
admin_obj.check(), [Error(msg, hint=hint, obj=invalid_obj, id=id)]
)
def assertIsInvalidRegexp(
self, model_admin, model, msg, id=None, hint=None, invalid_obj=None
):
"""
Same as assertIsInvalid but treats the given msg as a regexp.
"""
invalid_obj = invalid_obj or model_admin
admin_obj = model_admin(model, AdminSite())
errors = admin_obj.check()
self.assertEqual(len(errors), 1)
error = errors[0]
self.assertEqual(error.hint, hint)
self.assertEqual(error.obj, invalid_obj)
self.assertEqual(error.id, id)
self.assertRegex(error.msg, msg)
def assertIsValid(self, model_admin, model, admin_site=None):
if admin_site is None:
admin_site = AdminSite()
admin_obj = model_admin(model, admin_site)
self.assertEqual(admin_obj.check(), [])
class RawIdCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
raw_id_fields = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields' must be a list or tuple.",
"admin.E001",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
raw_id_fields = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields[0]' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E002",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
raw_id_fields = ("name",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields[0]' must be a foreign key or a "
"many-to-many field.",
"admin.E003",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
raw_id_fields = ("users",)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_field_attname(self):
class TestModelAdmin(ModelAdmin):
raw_id_fields = ["band_id"]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'raw_id_fields[0]' refers to 'band_id', which is "
"not a field of 'modeladmin.ValidationTestModel'.",
"admin.E002",
)
class FieldsetsCheckTests(CheckTestCase):
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
fieldsets = (("General", {"fields": ("name",)}),)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
fieldsets = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fieldsets' must be a list or tuple.",
"admin.E007",
)
def test_non_iterable_item(self):
class TestModelAdmin(ModelAdmin):
fieldsets = ({},)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fieldsets[0]' must be a list or tuple.",
"admin.E008",
)
def test_item_not_a_pair(self):
class TestModelAdmin(ModelAdmin):
fieldsets = ((),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fieldsets[0]' must be of length 2.",
"admin.E009",
)
def test_second_element_of_item_not_a_dict(self):
class TestModelAdmin(ModelAdmin):
fieldsets = (("General", ()),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fieldsets[0][1]' must be a dictionary.",
"admin.E010",
)
def test_missing_fields_key(self):
class TestModelAdmin(ModelAdmin):
fieldsets = (("General", {}),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fieldsets[0][1]' must contain the key 'fields'.",
"admin.E011",
)
class TestModelAdmin(ModelAdmin):
fieldsets = (("General", {"fields": ("name",)}),)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_specified_both_fields_and_fieldsets(self):
class TestModelAdmin(ModelAdmin):
fieldsets = (("General", {"fields": ("name",)}),)
fields = ["name"]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"Both 'fieldsets' and 'fields' are specified.",
"admin.E005",
)
def test_duplicate_fields(self):
class TestModelAdmin(ModelAdmin):
fieldsets = [(None, {"fields": ["name", "name"]})]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"There are duplicate field(s) in 'fieldsets[0][1]'.",
"admin.E012",
)
def test_duplicate_fields_in_fieldsets(self):
class TestModelAdmin(ModelAdmin):
fieldsets = [
(None, {"fields": ["name"]}),
(None, {"fields": ["name"]}),
]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"There are duplicate field(s) in 'fieldsets[1][1]'.",
"admin.E012",
)
def test_fieldsets_with_custom_form_validation(self):
class BandAdmin(ModelAdmin):
fieldsets = (("Band", {"fields": ("name",)}),)
self.assertIsValid(BandAdmin, Band)
class FieldsCheckTests(CheckTestCase):
def test_duplicate_fields_in_fields(self):
class TestModelAdmin(ModelAdmin):
fields = ["name", "name"]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fields' contains duplicate field(s).",
"admin.E006",
)
def test_inline(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
fields = 10
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'fields' must be a list or tuple.",
"admin.E004",
invalid_obj=ValidationTestInline,
)
class FormCheckTests(CheckTestCase):
def test_invalid_type(self):
class FakeForm:
pass
class TestModelAdmin(ModelAdmin):
form = FakeForm
class TestModelAdminWithNoForm(ModelAdmin):
form = "not a form"
for model_admin in (TestModelAdmin, TestModelAdminWithNoForm):
with self.subTest(model_admin):
self.assertIsInvalid(
model_admin,
ValidationTestModel,
"The value of 'form' must inherit from 'BaseModelForm'.",
"admin.E016",
)
def test_fieldsets_with_custom_form_validation(self):
class BandAdmin(ModelAdmin):
fieldsets = (("Band", {"fields": ("name",)}),)
self.assertIsValid(BandAdmin, Band)
def test_valid_case(self):
class AdminBandForm(forms.ModelForm):
delete = forms.BooleanField()
class BandAdmin(ModelAdmin):
form = AdminBandForm
fieldsets = (("Band", {"fields": ("name", "bio", "sign_date", "delete")}),)
self.assertIsValid(BandAdmin, Band)
class FilterVerticalCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
filter_vertical = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_vertical' must be a list or tuple.",
"admin.E017",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
filter_vertical = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_vertical[0]' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E019",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
filter_vertical = ("name",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_vertical[0]' must be a many-to-many field.",
"admin.E020",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
filter_vertical = ("users",)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class FilterHorizontalCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
filter_horizontal = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_horizontal' must be a list or tuple.",
"admin.E018",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
filter_horizontal = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_horizontal[0]' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E019",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
filter_horizontal = ("name",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'filter_horizontal[0]' must be a many-to-many field.",
"admin.E020",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
filter_horizontal = ("users",)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class RadioFieldsCheckTests(CheckTestCase):
def test_not_dictionary(self):
class TestModelAdmin(ModelAdmin):
radio_fields = ()
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'radio_fields' must be a dictionary.",
"admin.E021",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
radio_fields = {"non_existent_field": VERTICAL}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'radio_fields' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E022",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
radio_fields = {"name": VERTICAL}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'radio_fields' refers to 'name', which is not an instance "
"of ForeignKey, and does not have a 'choices' definition.",
"admin.E023",
)
def test_invalid_value(self):
class TestModelAdmin(ModelAdmin):
radio_fields = {"state": None}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'radio_fields[\"state\"]' must be either admin.HORIZONTAL or "
"admin.VERTICAL.",
"admin.E024",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
radio_fields = {"state": VERTICAL}
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class PrepopulatedFieldsCheckTests(CheckTestCase):
def test_not_list_or_tuple(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"slug": "test"}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields[\"slug\"]' must be a list or tuple.",
"admin.E029",
)
def test_not_dictionary(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = ()
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields' must be a dictionary.",
"admin.E026",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"non_existent_field": ("slug",)}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E027",
)
def test_missing_field_again(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"slug": ("non_existent_field",)}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields[\"slug\"][0]' refers to "
"'non_existent_field', which is not a field of "
"'modeladmin.ValidationTestModel'.",
"admin.E030",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"users": ("name",)}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields' refers to 'users', which must not be "
"a DateTimeField, a ForeignKey, a OneToOneField, or a ManyToManyField.",
"admin.E028",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"slug": ("name",)}
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_one_to_one_field(self):
class TestModelAdmin(ModelAdmin):
prepopulated_fields = {"best_friend": ("name",)}
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'prepopulated_fields' refers to 'best_friend', which must "
"not be a DateTimeField, a ForeignKey, a OneToOneField, or a "
"ManyToManyField.",
"admin.E028",
)
class ListDisplayTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
list_display = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display' must be a list or tuple.",
"admin.E107",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
list_display = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display[0]' refers to 'non_existent_field', "
"which is not a callable, an attribute of 'TestModelAdmin', "
"or an attribute or method on 'modeladmin.ValidationTestModel'.",
"admin.E108",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
list_display = ("users",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display[0]' must not be a ManyToManyField.",
"admin.E109",
)
def test_valid_case(self):
@admin.display
def a_callable(obj):
pass
class TestModelAdmin(ModelAdmin):
@admin.display
def a_method(self, obj):
pass
list_display = ("name", "decade_published_in", "a_method", a_callable)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_valid_field_accessible_via_instance(self):
class PositionField(Field):
"""Custom field accessible only via instance."""
def contribute_to_class(self, cls, name):
super().contribute_to_class(cls, name)
setattr(cls, self.name, self)
def __get__(self, instance, owner):
if instance is None:
raise AttributeError()
class TestModel(Model):
field = PositionField()
class TestModelAdmin(ModelAdmin):
list_display = ("field",)
self.assertIsValid(TestModelAdmin, TestModel)
class ListDisplayLinksCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
list_display_links = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display_links' must be a list, a tuple, or None.",
"admin.E110",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
list_display_links = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
(
"The value of 'list_display_links[0]' refers to "
"'non_existent_field', which is not defined in 'list_display'."
),
"admin.E111",
)
def test_missing_in_list_display(self):
class TestModelAdmin(ModelAdmin):
list_display_links = ("name",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display_links[0]' refers to 'name', which is not "
"defined in 'list_display'.",
"admin.E111",
)
def test_valid_case(self):
@admin.display
def a_callable(obj):
pass
class TestModelAdmin(ModelAdmin):
@admin.display
def a_method(self, obj):
pass
list_display = ("name", "decade_published_in", "a_method", a_callable)
list_display_links = ("name", "decade_published_in", "a_method", a_callable)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_None_is_valid_case(self):
class TestModelAdmin(ModelAdmin):
list_display_links = None
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_list_display_links_check_skipped_if_get_list_display_overridden(self):
"""
list_display_links check is skipped if get_list_display() is overridden.
"""
class TestModelAdmin(ModelAdmin):
list_display_links = ["name", "subtitle"]
def get_list_display(self, request):
pass
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_list_display_link_checked_for_list_tuple_if_get_list_display_overridden(
self,
):
"""
list_display_links is checked for list/tuple/None even if
get_list_display() is overridden.
"""
class TestModelAdmin(ModelAdmin):
list_display_links = "non-list/tuple"
def get_list_display(self, request):
pass
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_display_links' must be a list, a tuple, or None.",
"admin.E110",
)
class ListFilterTests(CheckTestCase):
def test_list_filter_validation(self):
class TestModelAdmin(ModelAdmin):
list_filter = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter' must be a list or tuple.",
"admin.E112",
)
def test_not_list_filter_class(self):
class TestModelAdmin(ModelAdmin):
list_filter = ["RandomClass"]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' refers to 'RandomClass', which "
"does not refer to a Field.",
"admin.E116",
)
def test_callable(self):
def random_callable():
pass
class TestModelAdmin(ModelAdmin):
list_filter = [random_callable]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' must inherit from 'ListFilter'.",
"admin.E113",
)
def test_not_callable(self):
class TestModelAdmin(ModelAdmin):
list_filter = [[42, 42]]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.",
"admin.E115",
)
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
list_filter = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' refers to 'non_existent_field', "
"which does not refer to a Field.",
"admin.E116",
)
def test_not_filter(self):
class RandomClass:
pass
class TestModelAdmin(ModelAdmin):
list_filter = (RandomClass,)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' must inherit from 'ListFilter'.",
"admin.E113",
)
def test_not_filter_again(self):
class RandomClass:
pass
class TestModelAdmin(ModelAdmin):
list_filter = (("is_active", RandomClass),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.",
"admin.E115",
)
def test_not_filter_again_again(self):
class AwesomeFilter(SimpleListFilter):
def get_title(self):
return "awesomeness"
def get_choices(self, request):
return (("bit", "A bit awesome"), ("very", "Very awesome"))
def get_queryset(self, cl, qs):
return qs
class TestModelAdmin(ModelAdmin):
list_filter = (("is_active", AwesomeFilter),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.",
"admin.E115",
)
def test_list_filter_is_func(self):
def get_filter():
pass
class TestModelAdmin(ModelAdmin):
list_filter = [get_filter]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' must inherit from 'ListFilter'.",
"admin.E113",
)
def test_not_associated_with_field_name(self):
class TestModelAdmin(ModelAdmin):
list_filter = (BooleanFieldListFilter,)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_filter[0]' must not inherit from 'FieldListFilter'.",
"admin.E114",
)
def test_valid_case(self):
class AwesomeFilter(SimpleListFilter):
def get_title(self):
return "awesomeness"
def get_choices(self, request):
return (("bit", "A bit awesome"), ("very", "Very awesome"))
def get_queryset(self, cl, qs):
return qs
class TestModelAdmin(ModelAdmin):
list_filter = (
"is_active",
AwesomeFilter,
("is_active", BooleanFieldListFilter),
"no",
)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class ListPerPageCheckTests(CheckTestCase):
def test_not_integer(self):
class TestModelAdmin(ModelAdmin):
list_per_page = "hello"
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_per_page' must be an integer.",
"admin.E118",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
list_per_page = 100
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class ListMaxShowAllCheckTests(CheckTestCase):
def test_not_integer(self):
class TestModelAdmin(ModelAdmin):
list_max_show_all = "hello"
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_max_show_all' must be an integer.",
"admin.E119",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
list_max_show_all = 200
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class SearchFieldsCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
search_fields = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'search_fields' must be a list or tuple.",
"admin.E126",
)
class DateHierarchyCheckTests(CheckTestCase):
def test_missing_field(self):
class TestModelAdmin(ModelAdmin):
date_hierarchy = "non_existent_field"
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'date_hierarchy' refers to 'non_existent_field', "
"which does not refer to a Field.",
"admin.E127",
)
def test_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
date_hierarchy = "name"
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'date_hierarchy' must be a DateField or DateTimeField.",
"admin.E128",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
date_hierarchy = "pub_date"
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_related_valid_case(self):
class TestModelAdmin(ModelAdmin):
date_hierarchy = "band__sign_date"
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_related_invalid_field_type(self):
class TestModelAdmin(ModelAdmin):
date_hierarchy = "band__name"
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'date_hierarchy' must be a DateField or DateTimeField.",
"admin.E128",
)
class OrderingCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
ordering = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'ordering' must be a list or tuple.",
"admin.E031",
)
class TestModelAdmin(ModelAdmin):
ordering = ("non_existent_field",)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'ordering[0]' refers to 'non_existent_field', "
"which is not a field of 'modeladmin.ValidationTestModel'.",
"admin.E033",
)
def test_random_marker_not_alone(self):
class TestModelAdmin(ModelAdmin):
ordering = ("?", "name")
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'ordering' has the random ordering marker '?', but contains "
"other fields as well.",
"admin.E032",
hint='Either remove the "?", or remove the other fields.',
)
def test_valid_random_marker_case(self):
class TestModelAdmin(ModelAdmin):
ordering = ("?",)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_valid_complex_case(self):
class TestModelAdmin(ModelAdmin):
ordering = ("band__name",)
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
ordering = ("name", "pk")
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_invalid_expression(self):
class TestModelAdmin(ModelAdmin):
ordering = (F("nonexistent"),)
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'ordering[0]' refers to 'nonexistent', which is not "
"a field of 'modeladmin.ValidationTestModel'.",
"admin.E033",
)
def test_valid_expression(self):
class TestModelAdmin(ModelAdmin):
ordering = (Upper("name"), Upper("band__name").desc())
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class ListSelectRelatedCheckTests(CheckTestCase):
def test_invalid_type(self):
class TestModelAdmin(ModelAdmin):
list_select_related = 1
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'list_select_related' must be a boolean, tuple or list.",
"admin.E117",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
list_select_related = False
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class SaveAsCheckTests(CheckTestCase):
def test_not_boolean(self):
class TestModelAdmin(ModelAdmin):
save_as = 1
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'save_as' must be a boolean.",
"admin.E101",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
save_as = True
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class SaveOnTopCheckTests(CheckTestCase):
def test_not_boolean(self):
class TestModelAdmin(ModelAdmin):
save_on_top = 1
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'save_on_top' must be a boolean.",
"admin.E102",
)
def test_valid_case(self):
class TestModelAdmin(ModelAdmin):
save_on_top = True
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class InlinesCheckTests(CheckTestCase):
def test_not_iterable(self):
class TestModelAdmin(ModelAdmin):
inlines = 10
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'inlines' must be a list or tuple.",
"admin.E103",
)
def test_not_correct_inline_field(self):
class TestModelAdmin(ModelAdmin):
inlines = [42]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"'.*\.TestModelAdmin' must inherit from 'InlineModelAdmin'\.",
"admin.E104",
)
def test_not_model_admin(self):
class ValidationTestInline:
pass
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"'.*\.ValidationTestInline' must inherit from 'InlineModelAdmin'\.",
"admin.E104",
)
def test_missing_model_field(self):
class ValidationTestInline(TabularInline):
pass
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"'.*\.ValidationTestInline' must have a 'model' attribute\.",
"admin.E105",
)
def test_invalid_model_type(self):
class SomethingBad:
pass
class ValidationTestInline(TabularInline):
model = SomethingBad
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"The value of '.*\.ValidationTestInline.model' must be a Model\.",
"admin.E106",
)
def test_invalid_model(self):
class ValidationTestInline(TabularInline):
model = "Not a class"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"The value of '.*\.ValidationTestInline.model' must be a Model\.",
"admin.E106",
)
def test_invalid_callable(self):
def random_obj():
pass
class TestModelAdmin(ModelAdmin):
inlines = [random_obj]
self.assertIsInvalidRegexp(
TestModelAdmin,
ValidationTestModel,
r"'.*\.random_obj' must inherit from 'InlineModelAdmin'\.",
"admin.E104",
)
def test_valid_case(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class FkNameCheckTests(CheckTestCase):
def test_missing_field(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
fk_name = "non_existent_field"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"'modeladmin.ValidationTestInlineModel' has no field named "
"'non_existent_field'.",
"admin.E202",
invalid_obj=ValidationTestInline,
)
def test_valid_case(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
fk_name = "parent"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
def test_proxy_model_parent(self):
class Parent(Model):
pass
class ProxyChild(Parent):
class Meta:
proxy = True
class ProxyProxyChild(ProxyChild):
class Meta:
proxy = True
class Related(Model):
proxy_child = ForeignKey(ProxyChild, on_delete=CASCADE)
class InlineFkName(admin.TabularInline):
model = Related
fk_name = "proxy_child"
class InlineNoFkName(admin.TabularInline):
model = Related
class ProxyProxyChildAdminFkName(admin.ModelAdmin):
inlines = [InlineFkName, InlineNoFkName]
self.assertIsValid(ProxyProxyChildAdminFkName, ProxyProxyChild)
class ExtraCheckTests(CheckTestCase):
def test_not_integer(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
extra = "hello"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'extra' must be an integer.",
"admin.E203",
invalid_obj=ValidationTestInline,
)
def test_valid_case(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
extra = 2
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class MaxNumCheckTests(CheckTestCase):
def test_not_integer(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
max_num = "hello"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'max_num' must be an integer.",
"admin.E204",
invalid_obj=ValidationTestInline,
)
def test_valid_case(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
max_num = 2
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class MinNumCheckTests(CheckTestCase):
def test_not_integer(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
min_num = "hello"
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'min_num' must be an integer.",
"admin.E205",
invalid_obj=ValidationTestInline,
)
def test_valid_case(self):
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
min_num = 2
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class FormsetCheckTests(CheckTestCase):
def test_invalid_type(self):
class FakeFormSet:
pass
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
formset = FakeFormSet
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsInvalid(
TestModelAdmin,
ValidationTestModel,
"The value of 'formset' must inherit from 'BaseModelFormSet'.",
"admin.E206",
invalid_obj=ValidationTestInline,
)
def test_inline_without_formset_class(self):
class ValidationTestInlineWithoutFormsetClass(TabularInline):
model = ValidationTestInlineModel
formset = "Not a FormSet Class"
class TestModelAdminWithoutFormsetClass(ModelAdmin):
inlines = [ValidationTestInlineWithoutFormsetClass]
self.assertIsInvalid(
TestModelAdminWithoutFormsetClass,
ValidationTestModel,
"The value of 'formset' must inherit from 'BaseModelFormSet'.",
"admin.E206",
invalid_obj=ValidationTestInlineWithoutFormsetClass,
)
def test_valid_case(self):
class RealModelFormSet(BaseModelFormSet):
pass
class ValidationTestInline(TabularInline):
model = ValidationTestInlineModel
formset = RealModelFormSet
class TestModelAdmin(ModelAdmin):
inlines = [ValidationTestInline]
self.assertIsValid(TestModelAdmin, ValidationTestModel)
class ListDisplayEditableTests(CheckTestCase):
def test_list_display_links_is_none(self):
"""
list_display and list_editable can contain the same values
when list_display_links is None
"""
class ProductAdmin(ModelAdmin):
list_display = ["name", "slug", "pub_date"]
list_editable = list_display
list_display_links = None
self.assertIsValid(ProductAdmin, ValidationTestModel)
def test_list_display_first_item_same_as_list_editable_first_item(self):
"""
The first item in list_display can be the same as the first in
list_editable.
"""
class ProductAdmin(ModelAdmin):
list_display = ["name", "slug", "pub_date"]
list_editable = ["name", "slug"]
list_display_links = ["pub_date"]
self.assertIsValid(ProductAdmin, ValidationTestModel)
def test_list_display_first_item_in_list_editable(self):
"""
The first item in list_display can be in list_editable as long as
list_display_links is defined.
"""
class ProductAdmin(ModelAdmin):
list_display = ["name", "slug", "pub_date"]
list_editable = ["slug", "name"]
list_display_links = ["pub_date"]
self.assertIsValid(ProductAdmin, ValidationTestModel)
def test_list_display_first_item_same_as_list_editable_no_list_display_links(self):
"""
The first item in list_display cannot be the same as the first item
in list_editable if list_display_links is not defined.
"""
class ProductAdmin(ModelAdmin):
list_display = ["name"]
list_editable = ["name"]
self.assertIsInvalid(
ProductAdmin,
ValidationTestModel,
"The value of 'list_editable[0]' refers to the first field "
"in 'list_display' ('name'), which cannot be used unless "
"'list_display_links' is set.",
id="admin.E124",
)
def test_list_display_first_item_in_list_editable_no_list_display_links(self):
"""
The first item in list_display cannot be in list_editable if
list_display_links isn't defined.
"""
class ProductAdmin(ModelAdmin):
list_display = ["name", "slug", "pub_date"]
list_editable = ["slug", "name"]
self.assertIsInvalid(
ProductAdmin,
ValidationTestModel,
"The value of 'list_editable[1]' refers to the first field "
"in 'list_display' ('name'), which cannot be used unless "
"'list_display_links' is set.",
id="admin.E124",
)
def test_both_list_editable_and_list_display_links(self):
class ProductAdmin(ModelAdmin):
list_editable = ("name",)
list_display = ("name",)
list_display_links = ("name",)
self.assertIsInvalid(
ProductAdmin,
ValidationTestModel,
"The value of 'name' cannot be in both 'list_editable' and "
"'list_display_links'.",
id="admin.E123",
)
class AutocompleteFieldsTests(CheckTestCase):
def test_autocomplete_e036(self):
class Admin(ModelAdmin):
autocomplete_fields = "name"
self.assertIsInvalid(
Admin,
Band,
msg="The value of 'autocomplete_fields' must be a list or tuple.",
id="admin.E036",
invalid_obj=Admin,
)
def test_autocomplete_e037(self):
class Admin(ModelAdmin):
autocomplete_fields = ("nonexistent",)
self.assertIsInvalid(
Admin,
ValidationTestModel,
msg=(
"The value of 'autocomplete_fields[0]' refers to 'nonexistent', "
"which is not a field of 'modeladmin.ValidationTestModel'."
),
id="admin.E037",
invalid_obj=Admin,
)
def test_autocomplete_e38(self):
class Admin(ModelAdmin):
autocomplete_fields = ("name",)
self.assertIsInvalid(
Admin,
ValidationTestModel,
msg=(
"The value of 'autocomplete_fields[0]' must be a foreign "
"key or a many-to-many field."
),
id="admin.E038",
invalid_obj=Admin,
)
def test_autocomplete_e039(self):
class Admin(ModelAdmin):
autocomplete_fields = ("band",)
self.assertIsInvalid(
Admin,
Song,
msg=(
'An admin for model "Band" has to be registered '
"to be referenced by Admin.autocomplete_fields."
),
id="admin.E039",
invalid_obj=Admin,
)
def test_autocomplete_e040(self):
class NoSearchFieldsAdmin(ModelAdmin):
pass
class AutocompleteAdmin(ModelAdmin):
autocomplete_fields = ("featuring",)
site = AdminSite()
site.register(Band, NoSearchFieldsAdmin)
self.assertIsInvalid(
AutocompleteAdmin,
Song,
msg=(
'NoSearchFieldsAdmin must define "search_fields", because '
"it's referenced by AutocompleteAdmin.autocomplete_fields."
),
id="admin.E040",
invalid_obj=AutocompleteAdmin,
admin_site=site,
)
def test_autocomplete_is_valid(self):
class SearchFieldsAdmin(ModelAdmin):
search_fields = "name"
class AutocompleteAdmin(ModelAdmin):
autocomplete_fields = ("featuring",)
site = AdminSite()
site.register(Band, SearchFieldsAdmin)
self.assertIsValid(AutocompleteAdmin, Song, admin_site=site)
def test_autocomplete_is_onetoone(self):
class UserAdmin(ModelAdmin):
search_fields = ("name",)
class Admin(ModelAdmin):
autocomplete_fields = ("best_friend",)
site = AdminSite()
site.register(User, UserAdmin)
self.assertIsValid(Admin, ValidationTestModel, admin_site=site)
class ActionsCheckTests(CheckTestCase):
def test_custom_permissions_require_matching_has_method(self):
@admin.action(permissions=["custom"])
def custom_permission_action(modeladmin, request, queryset):
pass
class BandAdmin(ModelAdmin):
actions = (custom_permission_action,)
self.assertIsInvalid(
BandAdmin,
Band,
"BandAdmin must define a has_custom_permission() method for the "
"custom_permission_action action.",
id="admin.E129",
)
def test_actions_not_unique(self):
@admin.action
def action(modeladmin, request, queryset):
pass
class BandAdmin(ModelAdmin):
actions = (action, action)
self.assertIsInvalid(
BandAdmin,
Band,
"__name__ attributes of actions defined in BandAdmin must be "
"unique. Name 'action' is not unique.",
id="admin.E130",
)
def test_actions_unique(self):
@admin.action
def action1(modeladmin, request, queryset):
pass
@admin.action
def action2(modeladmin, request, queryset):
pass
class BandAdmin(ModelAdmin):
actions = (action1, action2)
self.assertIsValid(BandAdmin, Band)