repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/version/__init__.py | tests/version/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/version/tests.py | tests/version/tests.py | from unittest import skipUnless
import django.utils.version
from django import get_version
from django.test import SimpleTestCase
from django.utils.version import (
get_complete_version,
get_git_changeset,
get_version_tuple,
)
class VersionTests(SimpleTestCase):
def test_development(self):
get_git_changeset.cache_clear()
ver_tuple = (1, 4, 0, "alpha", 0)
# This will return a different result when it's run within or outside
# of a git clone: 1.4.devYYYYMMDDHHMMSS or 1.4.
ver_string = get_version(ver_tuple)
self.assertRegex(ver_string, r"1\.4(\.dev[0-9]+)?")
@skipUnless(
hasattr(django.utils.version, "__file__"),
"test_development() checks the same when __file__ is already missing, "
"e.g. in a frozen environments",
)
def test_development_no_file(self):
get_git_changeset.cache_clear()
version_file = django.utils.version.__file__
try:
del django.utils.version.__file__
self.test_development()
finally:
django.utils.version.__file__ = version_file
def test_releases(self):
tuples_to_strings = (
((1, 4, 0, "alpha", 1), "1.4a1"),
((1, 4, 0, "beta", 1), "1.4b1"),
((1, 4, 0, "rc", 1), "1.4rc1"),
((1, 4, 0, "final", 0), "1.4"),
((1, 4, 1, "rc", 2), "1.4.1rc2"),
((1, 4, 1, "final", 0), "1.4.1"),
)
for ver_tuple, ver_string in tuples_to_strings:
self.assertEqual(get_version(ver_tuple), ver_string)
def test_get_version_tuple(self):
self.assertEqual(get_version_tuple("1.2.3"), (1, 2, 3))
self.assertEqual(get_version_tuple("1.2.3b2"), (1, 2, 3))
self.assertEqual(get_version_tuple("1.2.3b2.dev0"), (1, 2, 3))
def test_get_version_invalid_version(self):
tests = [
# Invalid length.
(3, 2, 0, "alpha", 1, "20210315111111"),
# Invalid development status.
(3, 2, 0, "gamma", 1, "20210315111111"),
]
for version in tests:
with self.subTest(version=version), self.assertRaises(AssertionError):
get_complete_version(version)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_filters/models.py | tests/admin_filters/models.py | from django.contrib.auth.models import User
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
class Book(models.Model):
title = models.CharField(max_length=50)
year = models.PositiveIntegerField(null=True, blank=True)
author = models.ForeignKey(
User,
models.SET_NULL,
verbose_name="Verbose Author",
related_name="books_authored",
blank=True,
null=True,
)
contributors = models.ManyToManyField(
User,
verbose_name="Verbose Contributors",
related_name="books_contributed",
blank=True,
)
employee = models.ForeignKey(
"Employee",
models.SET_NULL,
verbose_name="Employee",
blank=True,
null=True,
)
is_best_seller = models.BooleanField(default=0, null=True)
date_registered = models.DateField(null=True)
availability = models.BooleanField(
choices=(
(False, "Paid"),
(True, "Free"),
(None, "Obscure"),
),
null=True,
)
# This field name is intentionally 2 characters long (#16080).
no = models.IntegerField(verbose_name="number", blank=True, null=True)
CHOICES = [
("non-fiction", "Non-Fictional"),
("fiction", "Fictional"),
(None, "Not categorized"),
("", "We don't know"),
]
category = models.CharField(max_length=20, choices=CHOICES, blank=True, null=True)
def __str__(self):
return self.title
class ImprovedBook(models.Model):
book = models.OneToOneField(Book, models.CASCADE)
class Department(models.Model):
code = models.CharField(max_length=4, unique=True)
description = models.CharField(max_length=50, blank=True, null=True)
def __str__(self):
return self.description
class Employee(models.Model):
department = models.ForeignKey(Department, models.CASCADE, to_field="code")
name = models.CharField(max_length=100)
def __str__(self):
return self.name
class TaggedItem(models.Model):
tag = models.SlugField()
content_type = models.ForeignKey(
ContentType, models.CASCADE, related_name="tagged_items"
)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
def __str__(self):
return self.tag
class Bookmark(models.Model):
url = models.URLField()
tags = GenericRelation(TaggedItem)
CHOICES = [
("a", "A"),
(None, "None"),
("", "-"),
]
none_or_null = models.CharField(
max_length=20, choices=CHOICES, blank=True, null=True
)
def __str__(self):
return self.url
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_filters/__init__.py | tests/admin_filters/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_filters/tests.py | tests/admin_filters/tests.py | import datetime
import sys
import unittest
from django.contrib.admin import (
AllValuesFieldListFilter,
BooleanFieldListFilter,
EmptyFieldListFilter,
FieldListFilter,
ModelAdmin,
RelatedOnlyFieldListFilter,
SimpleListFilter,
site,
)
from django.contrib.admin.filters import FacetsMixin
from django.contrib.admin.options import IncorrectLookupParameters, ShowFacets
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User
from django.core.exceptions import ImproperlyConfigured
from django.db import connection, models
from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
from .models import Book, Bookmark, Department, Employee, ImprovedBook, TaggedItem
def select_by(dictlist, key, value):
return [x for x in dictlist if x[key] == value][0]
class DecadeListFilter(SimpleListFilter):
def lookups(self, request, model_admin):
return (
("the 80s", "the 1980's"),
("the 90s", "the 1990's"),
("the 00s", "the 2000's"),
("other", "other decades"),
)
def queryset(self, request, queryset):
decade = self.value()
if decade == "the 80s":
return queryset.filter(year__gte=1980, year__lte=1989)
if decade == "the 90s":
return queryset.filter(year__gte=1990, year__lte=1999)
if decade == "the 00s":
return queryset.filter(year__gte=2000, year__lte=2009)
class NotNinetiesListFilter(SimpleListFilter):
title = "Not nineties books"
parameter_name = "book_year"
def lookups(self, request, model_admin):
return (("the 90s", "the 1990's"),)
def queryset(self, request, queryset):
if self.value() == "the 90s":
return queryset.filter(year__gte=1990, year__lte=1999)
else:
return queryset.exclude(year__gte=1990, year__lte=1999)
class DecadeListFilterWithTitleAndParameter(DecadeListFilter):
title = "publication decade"
parameter_name = "publication-decade"
class DecadeListFilterWithoutTitle(DecadeListFilter):
parameter_name = "publication-decade"
class DecadeListFilterWithoutParameter(DecadeListFilter):
title = "publication decade"
class DecadeListFilterWithNoneReturningLookups(DecadeListFilterWithTitleAndParameter):
def lookups(self, request, model_admin):
pass
class DecadeListFilterWithFailingQueryset(DecadeListFilterWithTitleAndParameter):
def queryset(self, request, queryset):
raise 1 / 0
class DecadeListFilterWithQuerysetBasedLookups(DecadeListFilterWithTitleAndParameter):
def lookups(self, request, model_admin):
qs = model_admin.get_queryset(request)
if qs.filter(year__gte=1980, year__lte=1989).exists():
yield ("the 80s", "the 1980's")
if qs.filter(year__gte=1990, year__lte=1999).exists():
yield ("the 90s", "the 1990's")
if qs.filter(year__gte=2000, year__lte=2009).exists():
yield ("the 00s", "the 2000's")
class DecadeListFilterParameterEndsWith__In(DecadeListFilter):
title = "publication decade"
parameter_name = "decade__in" # Ends with '__in"
class DecadeListFilterParameterEndsWith__Isnull(DecadeListFilter):
title = "publication decade"
parameter_name = "decade__isnull" # Ends with '__isnull"
class DepartmentListFilterLookupWithNonStringValue(SimpleListFilter):
title = "department"
parameter_name = "department"
def lookups(self, request, model_admin):
return sorted(
{
(
employee.department.id, # Intentionally not a string (Refs #19318)
employee.department.code,
)
for employee in model_admin.get_queryset(request)
}
)
def queryset(self, request, queryset):
if self.value():
return queryset.filter(department__id=self.value())
class DepartmentListFilterLookupWithUnderscoredParameter(
DepartmentListFilterLookupWithNonStringValue
):
parameter_name = "department__whatever"
class DepartmentListFilterLookupWithDynamicValue(DecadeListFilterWithTitleAndParameter):
def lookups(self, request, model_admin):
if self.value() == "the 80s":
return (("the 90s", "the 1990's"),)
elif self.value() == "the 90s":
return (("the 80s", "the 1980's"),)
else:
return (
("the 80s", "the 1980's"),
("the 90s", "the 1990's"),
)
class EmployeeNameCustomDividerFilter(FieldListFilter):
list_separator = "|"
def __init__(self, field, request, params, model, model_admin, field_path):
self.lookup_kwarg = "%s__in" % field_path
super().__init__(field, request, params, model, model_admin, field_path)
def expected_parameters(self):
return [self.lookup_kwarg]
class DepartmentOwnershipListFilter(SimpleListFilter):
title = "Department Ownership"
parameter_name = "department_ownership"
def lookups(self, request, model_admin):
return [
("DEV_OWNED", "Owned by Dev Department"),
("OTHER", "Other"),
]
def queryset(self, request, queryset):
queryset = queryset.annotate(
owned_book_count=models.Count(
"employee__department",
filter=models.Q(employee__department__code="DEV"),
),
)
if self.value() == "DEV_OWNED":
return queryset.filter(owned_book_count__gt=0)
elif self.value() == "OTHER":
return queryset.filter(owned_book_count=0)
class CustomUserAdmin(UserAdmin):
list_filter = ("books_authored", "books_contributed")
class BookAdmin(ModelAdmin):
list_filter = (
"year",
"author",
"contributors",
"is_best_seller",
"date_registered",
"no",
"availability",
)
ordering = ("-id",)
class BookAdminWithTupleBooleanFilter(BookAdmin):
list_filter = (
"year",
"author",
"contributors",
("is_best_seller", BooleanFieldListFilter),
"date_registered",
"no",
("availability", BooleanFieldListFilter),
)
class BookAdminWithUnderscoreLookupAndTuple(BookAdmin):
list_filter = (
"year",
("author__email", AllValuesFieldListFilter),
"contributors",
"is_best_seller",
"date_registered",
"no",
)
class BookAdminWithCustomQueryset(ModelAdmin):
def __init__(self, user, *args, **kwargs):
self.user = user
super().__init__(*args, **kwargs)
list_filter = ("year",)
def get_queryset(self, request):
return super().get_queryset(request).filter(author=self.user)
class BookAdminRelatedOnlyFilter(ModelAdmin):
list_filter = (
"year",
"is_best_seller",
"date_registered",
"no",
("author", RelatedOnlyFieldListFilter),
("contributors", RelatedOnlyFieldListFilter),
("employee__department", RelatedOnlyFieldListFilter),
)
ordering = ("-id",)
class DecadeFilterBookAdmin(ModelAdmin):
empty_value_display = "???"
list_filter = (
"author",
DecadeListFilterWithTitleAndParameter,
"is_best_seller",
"category",
"date_registered",
("author__email", AllValuesFieldListFilter),
("contributors", RelatedOnlyFieldListFilter),
("category", EmptyFieldListFilter),
DepartmentOwnershipListFilter,
)
ordering = ("-id",)
class DecadeFilterBookAdminWithAlwaysFacets(DecadeFilterBookAdmin):
show_facets = ShowFacets.ALWAYS
class DecadeFilterBookAdminDisallowFacets(DecadeFilterBookAdmin):
show_facets = ShowFacets.NEVER
class NotNinetiesListFilterAdmin(ModelAdmin):
list_filter = (NotNinetiesListFilter,)
class DecadeFilterBookAdminWithoutTitle(ModelAdmin):
list_filter = (DecadeListFilterWithoutTitle,)
class DecadeFilterBookAdminWithoutParameter(ModelAdmin):
list_filter = (DecadeListFilterWithoutParameter,)
class DecadeFilterBookAdminWithNoneReturningLookups(ModelAdmin):
list_filter = (DecadeListFilterWithNoneReturningLookups,)
class DecadeFilterBookAdminWithFailingQueryset(ModelAdmin):
list_filter = (DecadeListFilterWithFailingQueryset,)
class DecadeFilterBookAdminWithQuerysetBasedLookups(ModelAdmin):
list_filter = (DecadeListFilterWithQuerysetBasedLookups,)
class DecadeFilterBookAdminParameterEndsWith__In(ModelAdmin):
list_filter = (DecadeListFilterParameterEndsWith__In,)
class DecadeFilterBookAdminParameterEndsWith__Isnull(ModelAdmin):
list_filter = (DecadeListFilterParameterEndsWith__Isnull,)
class EmployeeAdmin(ModelAdmin):
list_display = ["name", "department"]
list_filter = ["department"]
class EmployeeCustomDividerFilterAdmin(EmployeeAdmin):
list_filter = [
("name", EmployeeNameCustomDividerFilter),
]
class DepartmentFilterEmployeeAdmin(EmployeeAdmin):
list_filter = [DepartmentListFilterLookupWithNonStringValue]
class DepartmentFilterUnderscoredEmployeeAdmin(EmployeeAdmin):
list_filter = [DepartmentListFilterLookupWithUnderscoredParameter]
class DepartmentFilterDynamicValueBookAdmin(EmployeeAdmin):
list_filter = [DepartmentListFilterLookupWithDynamicValue]
class BookmarkAdminGenericRelation(ModelAdmin):
list_filter = ["tags__tag"]
class BookAdminWithEmptyFieldListFilter(ModelAdmin):
list_filter = [
("author", EmptyFieldListFilter),
("title", EmptyFieldListFilter),
("improvedbook", EmptyFieldListFilter),
]
class DepartmentAdminWithEmptyFieldListFilter(ModelAdmin):
list_filter = [
("description", EmptyFieldListFilter),
("employee", EmptyFieldListFilter),
]
class ListFiltersTests(TestCase):
request_factory = RequestFactory()
@classmethod
def setUpTestData(cls):
cls.today = datetime.date.today()
cls.tomorrow = cls.today + datetime.timedelta(days=1)
cls.one_week_ago = cls.today - datetime.timedelta(days=7)
if cls.today.month == 12:
cls.next_month = cls.today.replace(year=cls.today.year + 1, month=1, day=1)
else:
cls.next_month = cls.today.replace(month=cls.today.month + 1, day=1)
cls.next_year = cls.today.replace(year=cls.today.year + 1, month=1, day=1)
# Users
cls.alfred = User.objects.create_superuser(
"alfred", "alfred@example.com", "password"
)
cls.bob = User.objects.create_user("bob", "bob@example.com")
cls.lisa = User.objects.create_user("lisa", "lisa@example.com")
# Departments
cls.dev = Department.objects.create(code="DEV", description="Development")
cls.design = Department.objects.create(code="DSN", description="Design")
# Employees
cls.john = Employee.objects.create(name="John Blue", department=cls.dev)
cls.jack = Employee.objects.create(name="Jack Red", department=cls.design)
# Books
cls.djangonaut_book = Book.objects.create(
title="Djangonaut: an art of living",
year=2009,
author=cls.alfred,
is_best_seller=True,
date_registered=cls.today,
availability=True,
category="non-fiction",
employee=cls.john,
)
cls.bio_book = Book.objects.create(
title="Django: a biography",
year=1999,
author=cls.alfred,
is_best_seller=False,
no=207,
availability=False,
category="fiction",
employee=cls.john,
)
cls.django_book = Book.objects.create(
title="The Django Book",
year=None,
author=cls.bob,
is_best_seller=None,
date_registered=cls.today,
no=103,
availability=True,
employee=cls.jack,
)
cls.guitar_book = Book.objects.create(
title="Guitar for dummies",
year=2002,
is_best_seller=True,
date_registered=cls.one_week_ago,
availability=None,
category="",
)
cls.guitar_book.contributors.set([cls.bob, cls.lisa])
def assertChoicesDisplay(self, choices, expected_displays):
for choice, expected_display in zip(choices, expected_displays, strict=True):
self.assertEqual(choice["display"], expected_display)
def test_choicesfieldlistfilter_has_none_choice(self):
"""
The last choice is for the None value.
"""
class BookmarkChoicesAdmin(ModelAdmin):
list_display = ["none_or_null"]
list_filter = ["none_or_null"]
modeladmin = BookmarkChoicesAdmin(Bookmark, site)
request = self.request_factory.get("/", {})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
filterspec = changelist.get_filters(request)[0][0]
choices = list(filterspec.choices(changelist))
self.assertEqual(choices[-1]["display"], "None")
self.assertEqual(choices[-1]["query_string"], "?none_or_null__isnull=True")
def test_datefieldlistfilter(self):
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist(request)
request = self.request_factory.get(
"/",
{"date_registered__gte": self.today, "date_registered__lt": self.tomorrow},
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "Today")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"],
"?date_registered__gte=%s&date_registered__lt=%s"
% (
self.today,
self.tomorrow,
),
)
request = self.request_factory.get(
"/",
{
"date_registered__gte": self.today.replace(day=1),
"date_registered__lt": self.next_month,
},
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
if (self.today.year, self.today.month) == (
self.one_week_ago.year,
self.one_week_ago.month,
):
# In case one week ago is in the same month.
self.assertEqual(
list(queryset),
[self.guitar_book, self.django_book, self.djangonaut_book],
)
else:
self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "This month")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"],
"?date_registered__gte=%s&date_registered__lt=%s"
% (
self.today.replace(day=1),
self.next_month,
),
)
request = self.request_factory.get(
"/",
{
"date_registered__gte": self.today.replace(month=1, day=1),
"date_registered__lt": self.next_year,
},
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
if self.today.year == self.one_week_ago.year:
# In case one week ago is in the same year.
self.assertEqual(
list(queryset),
[self.guitar_book, self.django_book, self.djangonaut_book],
)
else:
self.assertEqual(list(queryset), [self.django_book, self.djangonaut_book])
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "This year")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"],
"?date_registered__gte=%s&date_registered__lt=%s"
% (
self.today.replace(month=1, day=1),
self.next_year,
),
)
request = self.request_factory.get(
"/",
{
"date_registered__gte": str(self.one_week_ago),
"date_registered__lt": str(self.tomorrow),
},
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(
list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "Past 7 days")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"],
"?date_registered__gte=%s&date_registered__lt=%s"
% (
str(self.one_week_ago),
str(self.tomorrow),
),
)
# Null/not null queries
request = self.request_factory.get("/", {"date_registered__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(queryset.count(), 1)
self.assertEqual(queryset[0], self.bio_book)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "No date")
self.assertIs(choice["selected"], True)
self.assertEqual(choice["query_string"], "?date_registered__isnull=True")
request = self.request_factory.get("/", {"date_registered__isnull": "False"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(queryset.count(), 3)
self.assertEqual(
list(queryset), [self.guitar_book, self.django_book, self.djangonaut_book]
)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][4]
self.assertEqual(filterspec.title, "date registered")
choice = select_by(filterspec.choices(changelist), "display", "Has date")
self.assertIs(choice["selected"], True)
self.assertEqual(choice["query_string"], "?date_registered__isnull=False")
@unittest.skipIf(
sys.platform == "win32",
"Windows doesn't support setting a timezone that differs from the "
"system timezone.",
)
@override_settings(USE_TZ=True)
def test_datefieldlistfilter_with_time_zone_support(self):
# Regression for #17830
self.test_datefieldlistfilter()
def test_allvaluesfieldlistfilter(self):
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/", {"year__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(list(queryset), [self.django_book])
# Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][0]
self.assertEqual(filterspec.title, "year")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[-1]["selected"], True)
self.assertEqual(choices[-1]["query_string"], "?year__isnull=True")
request = self.request_factory.get("/", {"year": "2002"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][0]
self.assertEqual(filterspec.title, "year")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[2]["selected"], True)
self.assertEqual(choices[2]["query_string"], "?year=2002")
def test_allvaluesfieldlistfilter_custom_qs(self):
# Make sure that correct filters are returned with custom querysets
modeladmin = BookAdminWithCustomQueryset(self.alfred, Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
filterspec = changelist.get_filters(request)[0][0]
choices = list(filterspec.choices(changelist))
# Should have 'All', 1999 and 2009 options i.e. the subset of years of
# books written by alfred (which is the filtering criteria set by
# BookAdminWithCustomQueryset.get_queryset())
self.assertEqual(3, len(choices))
self.assertEqual(choices[0]["query_string"], "?")
self.assertEqual(choices[1]["query_string"], "?year=1999")
self.assertEqual(choices[2]["query_string"], "?year=2009")
def test_relatedfieldlistfilter_foreignkey(self):
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure that all users are present in the author's list filter
filterspec = changelist.get_filters(request)[0][1]
expected = [
(self.alfred.pk, "alfred"),
(self.bob.pk, "bob"),
(self.lisa.pk, "lisa"),
]
self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
request = self.request_factory.get("/", {"author__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(list(queryset), [self.guitar_book])
# Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][1]
self.assertEqual(filterspec.title, "Verbose Author")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[-1]["selected"], True)
self.assertEqual(choices[-1]["query_string"], "?author__isnull=True")
request = self.request_factory.get("/", {"author__id__exact": self.alfred.pk})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][1]
self.assertEqual(filterspec.title, "Verbose Author")
# order of choices depends on User model, which has no order
choice = select_by(filterspec.choices(changelist), "display", "alfred")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"], "?author__id__exact=%d" % self.alfred.pk
)
def test_relatedfieldlistfilter_foreignkey_ordering(self):
"""RelatedFieldListFilter ordering respects ModelAdmin.ordering."""
class EmployeeAdminWithOrdering(ModelAdmin):
ordering = ("name",)
class BookAdmin(ModelAdmin):
list_filter = ("employee",)
site.register(Employee, EmployeeAdminWithOrdering)
self.addCleanup(lambda: site.unregister(Employee))
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
filterspec = changelist.get_filters(request)[0][0]
expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
self.assertEqual(filterspec.lookup_choices, expected)
def test_relatedfieldlistfilter_foreignkey_ordering_reverse(self):
class EmployeeAdminWithOrdering(ModelAdmin):
ordering = ("-name",)
class BookAdmin(ModelAdmin):
list_filter = ("employee",)
site.register(Employee, EmployeeAdminWithOrdering)
self.addCleanup(lambda: site.unregister(Employee))
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
filterspec = changelist.get_filters(request)[0][0]
expected = [(self.john.pk, "John Blue"), (self.jack.pk, "Jack Red")]
self.assertEqual(filterspec.lookup_choices, expected)
def test_relatedfieldlistfilter_foreignkey_default_ordering(self):
"""RelatedFieldListFilter ordering respects Model.ordering."""
class BookAdmin(ModelAdmin):
list_filter = ("employee",)
self.addCleanup(setattr, Employee._meta, "ordering", Employee._meta.ordering)
Employee._meta.ordering = ("name",)
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
filterspec = changelist.get_filters(request)[0][0]
expected = [(self.jack.pk, "Jack Red"), (self.john.pk, "John Blue")]
self.assertEqual(filterspec.lookup_choices, expected)
def test_relatedfieldlistfilter_manytomany(self):
modeladmin = BookAdmin(Book, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure that all users are present in the contrib's list filter
filterspec = changelist.get_filters(request)[0][2]
expected = [
(self.alfred.pk, "alfred"),
(self.bob.pk, "bob"),
(self.lisa.pk, "lisa"),
]
self.assertEqual(sorted(filterspec.lookup_choices), sorted(expected))
request = self.request_factory.get("/", {"contributors__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(
list(queryset), [self.django_book, self.bio_book, self.djangonaut_book]
)
# Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][2]
self.assertEqual(filterspec.title, "Verbose Contributors")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[-1]["selected"], True)
self.assertEqual(choices[-1]["query_string"], "?contributors__isnull=True")
request = self.request_factory.get(
"/", {"contributors__id__exact": self.bob.pk}
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][2]
self.assertEqual(filterspec.title, "Verbose Contributors")
choice = select_by(filterspec.choices(changelist), "display", "bob")
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"], "?contributors__id__exact=%d" % self.bob.pk
)
def test_relatedfieldlistfilter_reverse_relationships(self):
modeladmin = CustomUserAdmin(User, site)
# FK relationship -----
request = self.request_factory.get("/", {"books_authored__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(list(queryset), [self.lisa])
# Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][0]
self.assertEqual(filterspec.title, "book")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[-1]["selected"], True)
self.assertEqual(choices[-1]["query_string"], "?books_authored__isnull=True")
request = self.request_factory.get(
"/", {"books_authored__id__exact": self.bio_book.pk}
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][0]
self.assertEqual(filterspec.title, "book")
choice = select_by(
filterspec.choices(changelist), "display", self.bio_book.title
)
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"], "?books_authored__id__exact=%d" % self.bio_book.pk
)
# M2M relationship -----
request = self.request_factory.get("/", {"books_contributed__isnull": "True"})
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct queryset is returned
queryset = changelist.get_queryset(request)
self.assertEqual(list(queryset), [self.alfred])
# Make sure the last choice is None and is selected
filterspec = changelist.get_filters(request)[0][1]
self.assertEqual(filterspec.title, "book")
choices = list(filterspec.choices(changelist))
self.assertIs(choices[-1]["selected"], True)
self.assertEqual(choices[-1]["query_string"], "?books_contributed__isnull=True")
request = self.request_factory.get(
"/", {"books_contributed__id__exact": self.django_book.pk}
)
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
# Make sure the correct choice is selected
filterspec = changelist.get_filters(request)[0][1]
self.assertEqual(filterspec.title, "book")
choice = select_by(
filterspec.choices(changelist), "display", self.django_book.title
)
self.assertIs(choice["selected"], True)
self.assertEqual(
choice["query_string"],
"?books_contributed__id__exact=%d" % self.django_book.pk,
)
# With one book, the list filter should appear because there is also a
# (None) option.
Book.objects.exclude(pk=self.djangonaut_book.pk).delete()
filterspec = changelist.get_filters(request)[0]
self.assertEqual(len(filterspec), 2)
# With no books remaining, no list filters should appear.
Book.objects.all().delete()
filterspec = changelist.get_filters(request)[0]
self.assertEqual(len(filterspec), 0)
def test_relatedfieldlistfilter_reverse_relationships_default_ordering(self):
self.addCleanup(setattr, Book._meta, "ordering", Book._meta.ordering)
Book._meta.ordering = ("title",)
modeladmin = CustomUserAdmin(User, site)
request = self.request_factory.get("/")
request.user = self.alfred
changelist = modeladmin.get_changelist_instance(request)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/managers_regress/models.py | tests/managers_regress/models.py | """
Various edge-cases for model managers.
"""
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
class OnlyFred(models.Manager):
def get_queryset(self):
return super().get_queryset().filter(name="fred")
class OnlyBarney(models.Manager):
def get_queryset(self):
return super().get_queryset().filter(name="barney")
class Value42(models.Manager):
def get_queryset(self):
return super().get_queryset().filter(value=42)
class AbstractBase1(models.Model):
name = models.CharField(max_length=50)
class Meta:
abstract = True
# Custom managers
manager1 = OnlyFred()
manager2 = OnlyBarney()
objects = models.Manager()
class AbstractBase2(models.Model):
value = models.IntegerField()
class Meta:
abstract = True
# Custom manager
restricted = Value42()
# No custom manager on this class to make sure the default case doesn't break.
class AbstractBase3(models.Model):
comment = models.CharField(max_length=50)
class Meta:
abstract = True
class Parent(models.Model):
name = models.CharField(max_length=50)
manager = OnlyFred()
def __str__(self):
return self.name
# Managers from base classes are inherited and, if no manager is specified
# *and* the parent has a manager specified, the first one (in the MRO) will
# become the default.
class Child1(AbstractBase1):
data = models.CharField(max_length=25)
def __str__(self):
return self.data
class Child2(AbstractBase1, AbstractBase2):
data = models.CharField(max_length=25)
def __str__(self):
return self.data
class Child3(AbstractBase1, AbstractBase3):
data = models.CharField(max_length=25)
def __str__(self):
return self.data
class Child4(AbstractBase1):
data = models.CharField(max_length=25)
# Should be the default manager, although the parent managers are
# inherited.
default = models.Manager()
def __str__(self):
return self.data
class Child5(AbstractBase3):
name = models.CharField(max_length=25)
default = OnlyFred()
objects = models.Manager()
def __str__(self):
return self.name
class Child6(Child4):
value = models.IntegerField()
class Child7(Parent):
objects = models.Manager()
# RelatedManagers
class RelatedModel(models.Model):
test_gfk = GenericRelation(
"RelationModel", content_type_field="gfk_ctype", object_id_field="gfk_id"
)
exact = models.BooleanField(null=True)
def __str__(self):
return str(self.pk)
class RelationModel(models.Model):
fk = models.ForeignKey(RelatedModel, models.CASCADE, related_name="test_fk")
m2m = models.ManyToManyField(RelatedModel, related_name="test_m2m")
gfk_ctype = models.ForeignKey(ContentType, models.SET_NULL, null=True)
gfk_id = models.IntegerField(null=True)
gfk = GenericForeignKey(ct_field="gfk_ctype", fk_field="gfk_id")
def __str__(self):
return str(self.pk)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/managers_regress/__init__.py | tests/managers_regress/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/managers_regress/tests.py | tests/managers_regress/tests.py | from django.db import models
from django.template import Context, Template
from django.test import SimpleTestCase, TestCase, override_settings
from django.test.utils import isolate_apps
from .models import (
AbstractBase1,
AbstractBase2,
AbstractBase3,
Child1,
Child2,
Child3,
Child4,
Child5,
Child6,
Child7,
RelatedModel,
RelationModel,
)
class ManagersRegressionTests(TestCase):
def test_managers(self):
a1 = Child1.objects.create(name="fred", data="a1")
a2 = Child1.objects.create(name="barney", data="a2")
b1 = Child2.objects.create(name="fred", data="b1", value=1)
b2 = Child2.objects.create(name="barney", data="b2", value=42)
c1 = Child3.objects.create(name="fred", data="c1", comment="yes")
c2 = Child3.objects.create(name="barney", data="c2", comment="no")
d1 = Child4.objects.create(name="fred", data="d1")
d2 = Child4.objects.create(name="barney", data="d2")
fred1 = Child5.objects.create(name="fred", comment="yes")
Child5.objects.create(name="barney", comment="no")
f1 = Child6.objects.create(name="fred", data="f1", value=42)
f2 = Child6.objects.create(name="barney", data="f2", value=42)
fred2 = Child7.objects.create(name="fred")
barney = Child7.objects.create(name="barney")
self.assertSequenceEqual(Child1.manager1.all(), [a1])
self.assertSequenceEqual(Child1.manager2.all(), [a2])
self.assertSequenceEqual(Child1._default_manager.all(), [a1])
self.assertSequenceEqual(Child2._default_manager.all(), [b1])
self.assertSequenceEqual(Child2.restricted.all(), [b2])
self.assertSequenceEqual(Child3._default_manager.all(), [c1])
self.assertSequenceEqual(Child3.manager1.all(), [c1])
self.assertSequenceEqual(Child3.manager2.all(), [c2])
# Since Child6 inherits from Child4, the corresponding rows from f1 and
# f2 also appear here. This is the expected result.
self.assertSequenceEqual(
Child4._default_manager.order_by("data"),
[d1, d2, f1.child4_ptr, f2.child4_ptr],
)
self.assertCountEqual(Child4.manager1.all(), [d1, f1.child4_ptr])
self.assertCountEqual(Child5._default_manager.all(), [fred1])
self.assertCountEqual(Child6._default_manager.all(), [f1, f2])
self.assertSequenceEqual(
Child7._default_manager.order_by("name"),
[barney, fred2],
)
def test_abstract_manager(self):
# Accessing the manager on an abstract model should
# raise an attribute error with an appropriate message.
# This error message isn't ideal, but if the model is abstract and
# a lot of the class instantiation logic isn't invoked; if the
# manager is implied, then we don't get a hook to install the
# error-raising manager.
msg = "type object 'AbstractBase3' has no attribute 'objects'"
with self.assertRaisesMessage(AttributeError, msg):
AbstractBase3.objects.all()
def test_custom_abstract_manager(self):
# Accessing the manager on an abstract model with a custom
# manager should raise an attribute error with an appropriate
# message.
msg = "Manager isn't available; AbstractBase2 is abstract"
with self.assertRaisesMessage(AttributeError, msg):
AbstractBase2.restricted.all()
def test_explicit_abstract_manager(self):
# Accessing the manager on an abstract model with an explicit
# manager should raise an attribute error with an appropriate
# message.
msg = "Manager isn't available; AbstractBase1 is abstract"
with self.assertRaisesMessage(AttributeError, msg):
AbstractBase1.objects.all()
@override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
@isolate_apps("managers_regress")
def test_swappable_manager(self):
class SwappableModel(models.Model):
class Meta:
swappable = "TEST_SWAPPABLE_MODEL"
# Accessing the manager on a swappable model should
# raise an attribute error with a helpful message
msg = (
"Manager isn't available; 'managers_regress.SwappableModel' "
"has been swapped for 'managers_regress.Parent'"
)
with self.assertRaisesMessage(AttributeError, msg):
SwappableModel.objects.all()
@override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
@isolate_apps("managers_regress")
def test_custom_swappable_manager(self):
class SwappableModel(models.Model):
stuff = models.Manager()
class Meta:
swappable = "TEST_SWAPPABLE_MODEL"
# Accessing the manager on a swappable model with an
# explicit manager should raise an attribute error with a
# helpful message
msg = (
"Manager isn't available; 'managers_regress.SwappableModel' "
"has been swapped for 'managers_regress.Parent'"
)
with self.assertRaisesMessage(AttributeError, msg):
SwappableModel.stuff.all()
@override_settings(TEST_SWAPPABLE_MODEL="managers_regress.Parent")
@isolate_apps("managers_regress")
def test_explicit_swappable_manager(self):
class SwappableModel(models.Model):
objects = models.Manager()
class Meta:
swappable = "TEST_SWAPPABLE_MODEL"
# Accessing the manager on a swappable model with an
# explicit manager should raise an attribute error with a
# helpful message
msg = (
"Manager isn't available; 'managers_regress.SwappableModel' "
"has been swapped for 'managers_regress.Parent'"
)
with self.assertRaisesMessage(AttributeError, msg):
SwappableModel.objects.all()
def test_regress_3871(self):
related = RelatedModel.objects.create()
relation = RelationModel()
relation.fk = related
relation.gfk = related
relation.save()
relation.m2m.add(related)
t = Template(
"{{ related.test_fk.all.0 }}{{ related.test_gfk.all.0 }}"
"{{ related.test_m2m.all.0 }}"
)
self.assertEqual(
t.render(Context({"related": related})),
"".join([str(relation.pk)] * 3),
)
def test_field_can_be_called_exact(self):
# Make sure related managers core filters don't include an
# explicit `__exact` lookup that could be interpreted as a
# reference to a foreign `exact` field. refs #23940.
related = RelatedModel.objects.create(exact=False)
relation = related.test_fk.create()
self.assertEqual(related.test_fk.get(), relation)
@isolate_apps("managers_regress")
class TestManagerInheritance(SimpleTestCase):
def test_implicit_inheritance(self):
class CustomManager(models.Manager):
pass
class AbstractModel(models.Model):
custom_manager = CustomManager()
class Meta:
abstract = True
class PlainModel(models.Model):
custom_manager = CustomManager()
self.assertIsInstance(PlainModel._base_manager, models.Manager)
self.assertIsInstance(PlainModel._default_manager, CustomManager)
class ModelWithAbstractParent(AbstractModel):
pass
self.assertIsInstance(ModelWithAbstractParent._base_manager, models.Manager)
self.assertIsInstance(ModelWithAbstractParent._default_manager, CustomManager)
class ProxyModel(PlainModel):
class Meta:
proxy = True
self.assertIsInstance(ProxyModel._base_manager, models.Manager)
self.assertIsInstance(ProxyModel._default_manager, CustomManager)
class MTIModel(PlainModel):
pass
self.assertIsInstance(MTIModel._base_manager, models.Manager)
self.assertIsInstance(MTIModel._default_manager, CustomManager)
def test_default_manager_inheritance(self):
class CustomManager(models.Manager):
pass
class AbstractModel(models.Model):
another_manager = models.Manager()
custom_manager = CustomManager()
class Meta:
default_manager_name = "custom_manager"
abstract = True
class PlainModel(models.Model):
another_manager = models.Manager()
custom_manager = CustomManager()
class Meta:
default_manager_name = "custom_manager"
self.assertIsInstance(PlainModel._default_manager, CustomManager)
class ModelWithAbstractParent(AbstractModel):
pass
self.assertIsInstance(ModelWithAbstractParent._default_manager, CustomManager)
class ProxyModel(PlainModel):
class Meta:
proxy = True
self.assertIsInstance(ProxyModel._default_manager, CustomManager)
class MTIModel(PlainModel):
pass
self.assertIsInstance(MTIModel._default_manager, CustomManager)
def test_base_manager_inheritance(self):
class CustomManager(models.Manager):
pass
class AbstractModel(models.Model):
another_manager = models.Manager()
custom_manager = CustomManager()
class Meta:
base_manager_name = "custom_manager"
abstract = True
class PlainModel(models.Model):
another_manager = models.Manager()
custom_manager = CustomManager()
class Meta:
base_manager_name = "custom_manager"
self.assertIsInstance(PlainModel._base_manager, CustomManager)
class ModelWithAbstractParent(AbstractModel):
pass
self.assertIsInstance(ModelWithAbstractParent._base_manager, CustomManager)
class ProxyModel(PlainModel):
class Meta:
proxy = True
self.assertIsInstance(ProxyModel._base_manager, CustomManager)
class MTIModel(PlainModel):
pass
self.assertIsInstance(MTIModel._base_manager, CustomManager)
def test_manager_no_duplicates(self):
class CustomManager(models.Manager):
pass
class AbstractModel(models.Model):
custom_manager = models.Manager()
class Meta:
abstract = True
class TestModel(AbstractModel):
custom_manager = CustomManager()
self.assertEqual(TestModel._meta.managers, (TestModel.custom_manager,))
self.assertEqual(
TestModel._meta.managers_map, {"custom_manager": TestModel.custom_manager}
)
def test_manager_class_getitem(self):
self.assertIs(models.Manager[Child1], models.Manager)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_inheritance/test_abstract_inheritance.py | tests/model_inheritance/test_abstract_inheritance.py | from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.core.checks import Error
from django.core.exceptions import FieldDoesNotExist, FieldError
from django.db import models
from django.test import SimpleTestCase
from django.test.utils import isolate_apps
@isolate_apps("model_inheritance")
class AbstractInheritanceTests(SimpleTestCase):
def test_single_parent(self):
class AbstractBase(models.Model):
name = models.CharField(max_length=30)
class Meta:
abstract = True
class AbstractDescendant(AbstractBase):
name = models.CharField(max_length=50)
class Meta:
abstract = True
class DerivedChild(AbstractBase):
name = models.CharField(max_length=50)
class DerivedGrandChild(AbstractDescendant):
pass
self.assertEqual(AbstractDescendant._meta.get_field("name").max_length, 50)
self.assertEqual(DerivedChild._meta.get_field("name").max_length, 50)
self.assertEqual(DerivedGrandChild._meta.get_field("name").max_length, 50)
def test_multiple_inheritance_allows_inherited_field(self):
"""
Single layer multiple inheritance is as expected, deriving the
inherited field from the first base.
"""
class ParentA(models.Model):
name = models.CharField(max_length=255)
class Meta:
abstract = True
class ParentB(models.Model):
name = models.IntegerField()
class Meta:
abstract = True
class Child(ParentA, ParentB):
pass
self.assertEqual(Child.check(), [])
inherited_field = Child._meta.get_field("name")
self.assertIsInstance(inherited_field, models.CharField)
self.assertEqual(inherited_field.max_length, 255)
def test_diamond_shaped_multiple_inheritance_is_depth_first(self):
"""
In contrast to standard Python MRO, resolution of inherited fields is
strictly depth-first, rather than breadth-first in diamond-shaped
cases.
This is because a copy of the parent field descriptor is placed onto
the model class in ModelBase.__new__(), rather than the attribute
lookup going via bases. (It only **looks** like inheritance.)
Here, Child inherits name from Root, rather than ParentB.
"""
class Root(models.Model):
name = models.CharField(max_length=255)
class Meta:
abstract = True
class ParentA(Root):
class Meta:
abstract = True
class ParentB(Root):
name = models.IntegerField()
class Meta:
abstract = True
class Child(ParentA, ParentB):
pass
self.assertEqual(Child.check(), [])
inherited_field = Child._meta.get_field("name")
self.assertIsInstance(inherited_field, models.CharField)
self.assertEqual(inherited_field.max_length, 255)
def test_target_field_may_be_pushed_down(self):
"""
Where the Child model needs to inherit a field from a different base
than that given by depth-first resolution, the target field can be
**pushed down** by being re-declared.
"""
class Root(models.Model):
name = models.CharField(max_length=255)
class Meta:
abstract = True
class ParentA(Root):
class Meta:
abstract = True
class ParentB(Root):
name = models.IntegerField()
class Meta:
abstract = True
class Child(ParentA, ParentB):
name = models.IntegerField()
self.assertEqual(Child.check(), [])
inherited_field = Child._meta.get_field("name")
self.assertIsInstance(inherited_field, models.IntegerField)
def test_multiple_inheritance_cannot_shadow_concrete_inherited_field(self):
class ConcreteParent(models.Model):
name = models.CharField(max_length=255)
class AbstractParent(models.Model):
name = models.IntegerField()
class Meta:
abstract = True
class FirstChild(ConcreteParent, AbstractParent):
pass
class AnotherChild(AbstractParent, ConcreteParent):
pass
self.assertIsInstance(FirstChild._meta.get_field("name"), models.CharField)
self.assertEqual(
AnotherChild.check(),
[
Error(
"The field 'name' clashes with the field 'name' "
"from model 'model_inheritance.concreteparent'.",
obj=AnotherChild._meta.get_field("name"),
id="models.E006",
)
],
)
def test_virtual_field(self):
class RelationModel(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
class RelatedModelAbstract(models.Model):
field = GenericRelation(RelationModel)
class Meta:
abstract = True
class ModelAbstract(models.Model):
field = models.CharField(max_length=100)
class Meta:
abstract = True
class OverrideRelatedModelAbstract(RelatedModelAbstract):
field = models.CharField(max_length=100)
class ExtendModelAbstract(ModelAbstract):
field = GenericRelation(RelationModel)
self.assertIsInstance(
OverrideRelatedModelAbstract._meta.get_field("field"), models.CharField
)
self.assertIsInstance(
ExtendModelAbstract._meta.get_field("field"), GenericRelation
)
def test_override_private_field_with_attr(self):
class AbstractBase(models.Model):
content_type = models.ForeignKey(
ContentType, on_delete=models.SET_NULL, null=True, blank=True
)
object_id = models.PositiveIntegerField(null=True, blank=True)
related_object = GenericForeignKey("content_type", "object_id")
class Meta:
abstract = True
class Descendant(AbstractBase):
related_object = None
class Mixin:
related_object = None
class MultiDescendant(Mixin, AbstractBase):
pass
with self.assertRaises(FieldDoesNotExist):
Descendant._meta.get_field("related_object")
with self.assertRaises(FieldDoesNotExist):
MultiDescendant._meta.get_field("related_object")
def test_cannot_override_indirect_abstract_field(self):
class AbstractBase(models.Model):
name = models.CharField(max_length=30)
class Meta:
abstract = True
class ConcreteDescendant(AbstractBase):
pass
msg = (
"Local field 'name' in class 'Descendant' clashes with field of "
"the same name from base class 'ConcreteDescendant'."
)
with self.assertRaisesMessage(FieldError, msg):
class Descendant(ConcreteDescendant):
name = models.IntegerField()
def test_override_field_with_attr(self):
class AbstractBase(models.Model):
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
middle_name = models.CharField(max_length=30)
full_name = models.CharField(max_length=150)
class Meta:
abstract = True
class Descendant(AbstractBase):
middle_name = None
def full_name(self):
return self.first_name + self.last_name
msg = "Descendant has no field named %r"
with self.assertRaisesMessage(FieldDoesNotExist, msg % "middle_name"):
Descendant._meta.get_field("middle_name")
with self.assertRaisesMessage(FieldDoesNotExist, msg % "full_name"):
Descendant._meta.get_field("full_name")
def test_overriding_field_removed_by_concrete_model(self):
class AbstractModel(models.Model):
foo = models.CharField(max_length=30)
class Meta:
abstract = True
class RemovedAbstractModelField(AbstractModel):
foo = None
class OverrideRemovedFieldByConcreteModel(RemovedAbstractModelField):
foo = models.CharField(max_length=50)
self.assertEqual(
OverrideRemovedFieldByConcreteModel._meta.get_field("foo").max_length, 50
)
def test_shadowed_fkey_id(self):
class Foo(models.Model):
pass
class AbstractBase(models.Model):
foo = models.ForeignKey(Foo, models.CASCADE)
class Meta:
abstract = True
class Descendant(AbstractBase):
foo_id = models.IntegerField()
self.assertEqual(
Descendant.check(),
[
Error(
"The field 'foo_id' clashes with the field 'foo' "
"from model 'model_inheritance.descendant'.",
obj=Descendant._meta.get_field("foo_id"),
id="models.E006",
)
],
)
def test_shadow_related_name_when_set_to_none(self):
class AbstractBase(models.Model):
bar = models.IntegerField()
class Meta:
abstract = True
class Foo(AbstractBase):
bar = None
foo = models.IntegerField()
class Bar(models.Model):
bar = models.ForeignKey(Foo, models.CASCADE, related_name="bar")
self.assertEqual(Bar.check(), [])
def test_reverse_foreign_key(self):
class AbstractBase(models.Model):
foo = models.CharField(max_length=100)
class Meta:
abstract = True
class Descendant(AbstractBase):
pass
class Foo(models.Model):
foo = models.ForeignKey(Descendant, models.CASCADE, related_name="foo")
self.assertEqual(
Foo._meta.get_field("foo").check(),
[
Error(
"Reverse accessor 'Descendant.foo' for "
"'model_inheritance.Foo.foo' clashes with field name "
"'model_inheritance.Descendant.foo'.",
hint=(
"Rename field 'model_inheritance.Descendant.foo', or "
"add/change a related_name argument to the definition "
"for field 'model_inheritance.Foo.foo'."
),
obj=Foo._meta.get_field("foo"),
id="fields.E302",
),
Error(
"Reverse query name for 'model_inheritance.Foo.foo' "
"clashes with field name "
"'model_inheritance.Descendant.foo'.",
hint=(
"Rename field 'model_inheritance.Descendant.foo', or "
"add/change a related_name argument to the definition "
"for field 'model_inheritance.Foo.foo'."
),
obj=Foo._meta.get_field("foo"),
id="fields.E303",
),
],
)
def test_multi_inheritance_field_clashes(self):
class AbstractBase(models.Model):
name = models.CharField(max_length=30)
class Meta:
abstract = True
class ConcreteBase(AbstractBase):
pass
class AbstractDescendant(ConcreteBase):
class Meta:
abstract = True
class ConcreteDescendant(AbstractDescendant):
name = models.CharField(max_length=100)
self.assertEqual(
ConcreteDescendant.check(),
[
Error(
"The field 'name' clashes with the field 'name' from "
"model 'model_inheritance.concretebase'.",
obj=ConcreteDescendant._meta.get_field("name"),
id="models.E006",
)
],
)
def test_override_one2one_relation_auto_field_clashes(self):
class ConcreteParent(models.Model):
name = models.CharField(max_length=255)
class AbstractParent(models.Model):
name = models.IntegerField()
class Meta:
abstract = True
msg = (
"Auto-generated field 'concreteparent_ptr' in class 'Descendant' "
"for parent_link to base class 'ConcreteParent' clashes with "
"declared field of the same name."
)
with self.assertRaisesMessage(FieldError, msg):
class Descendant(ConcreteParent, AbstractParent):
concreteparent_ptr = models.CharField(max_length=30)
def test_abstract_model_with_regular_python_mixin_mro(self):
class AbstractModel(models.Model):
name = models.CharField(max_length=255)
age = models.IntegerField()
class Meta:
abstract = True
class Mixin:
age = None
class Mixin2:
age = 2
class DescendantMixin(Mixin):
pass
class ConcreteModel(models.Model):
foo = models.IntegerField()
class ConcreteModel2(ConcreteModel):
age = models.SmallIntegerField()
def fields(model):
if not hasattr(model, "_meta"):
return []
return [(f.name, f.__class__) for f in model._meta.get_fields()]
model_dict = {"__module__": "model_inheritance"}
model1 = type("Model1", (AbstractModel, Mixin), model_dict.copy())
model2 = type("Model2", (Mixin2, AbstractModel), model_dict.copy())
model3 = type("Model3", (DescendantMixin, AbstractModel), model_dict.copy())
model4 = type("Model4", (Mixin2, Mixin, AbstractModel), model_dict.copy())
model5 = type(
"Model5", (Mixin2, ConcreteModel2, Mixin, AbstractModel), model_dict.copy()
)
self.assertEqual(
fields(model1),
[
("id", models.BigAutoField),
("name", models.CharField),
("age", models.IntegerField),
],
)
self.assertEqual(
fields(model2), [("id", models.BigAutoField), ("name", models.CharField)]
)
self.assertEqual(getattr(model2, "age"), 2)
self.assertEqual(
fields(model3), [("id", models.BigAutoField), ("name", models.CharField)]
)
self.assertEqual(
fields(model4), [("id", models.BigAutoField), ("name", models.CharField)]
)
self.assertEqual(getattr(model4, "age"), 2)
self.assertEqual(
fields(model5),
[
("id", models.BigAutoField),
("foo", models.IntegerField),
("concretemodel_ptr", models.OneToOneField),
("age", models.SmallIntegerField),
("concretemodel2_ptr", models.OneToOneField),
("name", models.CharField),
],
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_inheritance/models.py | tests/model_inheritance/models.py | """
XX. Model inheritance
Model inheritance exists in two varieties:
- abstract base classes which are a way of specifying common
information inherited by the subclasses. They don't exist as a separate
model.
- non-abstract base classes (the default), which are models in their own
right with their own database tables and everything. Their subclasses
have references back to them, created automatically.
Both styles are demonstrated here.
"""
from django.db import models
#
# Abstract base classes
#
class CommonInfo(models.Model):
name = models.CharField(max_length=50)
age = models.PositiveIntegerField()
class Meta:
abstract = True
ordering = ["name"]
def __str__(self):
return "%s %s" % (self.__class__.__name__, self.name)
class Worker(CommonInfo):
job = models.CharField(max_length=50)
class Student(CommonInfo):
school_class = models.CharField(max_length=10)
class Meta:
pass
#
# Abstract base classes with related models
#
class Post(models.Model):
title = models.CharField(max_length=50)
class Attachment(models.Model):
post = models.ForeignKey(
Post,
models.CASCADE,
related_name="attached_%(class)s_set",
related_query_name="attached_%(app_label)s_%(class)ss",
)
content = models.TextField()
class Meta:
abstract = True
class Comment(Attachment):
is_spam = models.BooleanField(default=False)
class Link(Attachment):
url = models.URLField()
#
# Multi-table inheritance
#
class Chef(models.Model):
name = models.CharField(max_length=50)
class Place(models.Model):
name = models.CharField(max_length=50)
address = models.CharField(max_length=80)
class Rating(models.Model):
rating = models.IntegerField(null=True, blank=True)
class Meta:
abstract = True
ordering = ["-rating"]
class Restaurant(Place, Rating):
serves_hot_dogs = models.BooleanField(default=False)
serves_pizza = models.BooleanField(default=False)
chef = models.ForeignKey(Chef, models.SET_NULL, null=True, blank=True)
class Meta(Rating.Meta):
db_table = "my_restaurant"
class ItalianRestaurant(Restaurant):
serves_gnocchi = models.BooleanField(default=False)
class ItalianRestaurantCommonParent(ItalianRestaurant, Place):
place_ptr_two = models.OneToOneField(
Place, on_delete=models.CASCADE, parent_link=True
)
class Supplier(Place):
customers = models.ManyToManyField(Restaurant, related_name="provider")
class CustomSupplier(Supplier):
pass
class ParkingLot(Place):
# An explicit link to the parent (we can control the attribute name).
parent = models.OneToOneField(
Place, models.CASCADE, primary_key=True, parent_link=True
)
main_site = models.ForeignKey(Place, models.CASCADE, related_name="lot")
#
# Abstract base classes with related models where the sub-class has the
# same name in a different app and inherits from the same abstract base
# class.
# NOTE: The actual API tests for the following classes are in
# model_inheritance_same_model_name/models.py - They are defined
# here in order to have the name conflict between apps
#
class Title(models.Model):
title = models.CharField(max_length=50)
class NamedURL(models.Model):
title = models.ForeignKey(
Title, models.CASCADE, related_name="attached_%(app_label)s_%(class)s_set"
)
url = models.URLField()
class Meta:
abstract = True
class Mixin:
def __init__(self):
self.other_attr = 1
super().__init__()
class MixinModel(models.Model, Mixin):
pass
class Base(models.Model):
titles = models.ManyToManyField(Title)
class SubBase(Base):
sub_id = models.IntegerField(primary_key=True)
class GrandParent(models.Model):
first_name = models.CharField(max_length=80)
last_name = models.CharField(max_length=80)
email = models.EmailField(unique=True)
place = models.ForeignKey(Place, models.CASCADE, null=True, related_name="+")
class Meta:
# Ordering used by test_inherited_ordering_pk_desc.
ordering = ["-pk"]
unique_together = ("first_name", "last_name")
class Parent(GrandParent):
pass
class Child(Parent):
pass
class GrandChild(Child):
pass
class CommonAncestor(models.Model):
id = models.IntegerField(primary_key=True, default=1)
class FirstParent(CommonAncestor):
first_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class SecondParent(CommonAncestor):
second_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class CommonChild(FirstParent, SecondParent):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_inheritance/__init__.py | tests/model_inheritance/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_inheritance/tests.py | tests/model_inheritance/tests.py | from operator import attrgetter
from django.core.exceptions import FieldError, ValidationError
from django.db import connection, models
from django.db.models.query_utils import DeferredAttribute
from django.test import SimpleTestCase, TestCase
from django.test.utils import CaptureQueriesContext, isolate_apps
from .models import (
Base,
Chef,
CommonChild,
CommonInfo,
CustomSupplier,
GrandChild,
GrandParent,
ItalianRestaurant,
ItalianRestaurantCommonParent,
MixinModel,
Parent,
ParkingLot,
Place,
Post,
Restaurant,
Student,
SubBase,
Supplier,
Title,
Worker,
)
class ModelInheritanceTests(TestCase):
def test_abstract(self):
# The Student and Worker models both have 'name' and 'age' fields on
# them and inherit the __str__() method, just as with normal Python
# subclassing. This is useful if you want to factor out common
# information for programming purposes, but still completely
# independent separate models at the database level.
w1 = Worker.objects.create(name="Fred", age=35, job="Quarry worker")
Worker.objects.create(name="Barney", age=34, job="Quarry worker")
s = Student.objects.create(name="Pebbles", age=5, school_class="1B")
self.assertEqual(str(w1), "Worker Fred")
self.assertEqual(str(s), "Student Pebbles")
# The children inherit the Meta class of their parents (if they don't
# specify their own).
self.assertSequenceEqual(
Worker.objects.values("name"),
[
{"name": "Barney"},
{"name": "Fred"},
],
)
# Since Student does not subclass CommonInfo's Meta, it has the effect
# of completely overriding it. So ordering by name doesn't take place
# for Students.
self.assertEqual(Student._meta.ordering, [])
# However, the CommonInfo class cannot be used as a normal model (it
# doesn't exist as a model).
with self.assertRaisesMessage(
AttributeError, "'CommonInfo' has no attribute 'objects'"
):
CommonInfo.objects.all()
def test_reverse_relation_for_different_hierarchy_tree(self):
# Even though p.supplier for a Place 'p' (a parent of a Supplier), a
# Restaurant object cannot access that reverse relation, since it's not
# part of the Place-Supplier Hierarchy.
self.assertSequenceEqual(Place.objects.filter(supplier__name="foo"), [])
msg = (
"Cannot resolve keyword 'supplier' into field. Choices are: "
"address, chef, chef_id, id, italianrestaurant, lot, name, "
"place_ptr, place_ptr_id, provider, rating, serves_hot_dogs, serves_pizza"
)
with self.assertRaisesMessage(FieldError, msg):
Restaurant.objects.filter(supplier__name="foo")
def test_model_with_distinct_accessors(self):
# The Post model has distinct accessors for the Comment and Link
# models.
post = Post.objects.create(title="Lorem Ipsum")
post.attached_comment_set.create(content="Save $ on V1agr@", is_spam=True)
post.attached_link_set.create(
content="The web framework for perfections with deadlines.",
url="http://www.djangoproject.com/",
)
# The Post model doesn't have an attribute called
# 'attached_%(class)s_set'.
msg = "'Post' object has no attribute 'attached_%(class)s_set'"
with self.assertRaisesMessage(AttributeError, msg):
getattr(post, "attached_%(class)s_set")
def test_model_with_distinct_related_query_name(self):
self.assertSequenceEqual(
Post.objects.filter(attached_model_inheritance_comments__is_spam=True), []
)
# The Post model doesn't have a related query accessor based on
# related_name (attached_comment_set).
msg = "Cannot resolve keyword 'attached_comment_set' into field."
with self.assertRaisesMessage(FieldError, msg):
Post.objects.filter(attached_comment_set__is_spam=True)
def test_meta_fields_and_ordering(self):
# Make sure Restaurant and ItalianRestaurant have the right fields in
# the right order.
self.assertEqual(
[f.name for f in Restaurant._meta.fields],
[
"id",
"name",
"address",
"place_ptr",
"rating",
"serves_hot_dogs",
"serves_pizza",
"chef",
],
)
self.assertEqual(
[f.name for f in ItalianRestaurant._meta.fields],
[
"id",
"name",
"address",
"place_ptr",
"rating",
"serves_hot_dogs",
"serves_pizza",
"chef",
"restaurant_ptr",
"serves_gnocchi",
],
)
self.assertEqual(Restaurant._meta.ordering, ["-rating"])
def test_custompk_m2m(self):
b = Base.objects.create()
b.titles.add(Title.objects.create(title="foof"))
s = SubBase.objects.create(sub_id=b.id)
b = Base.objects.get(pk=s.id)
self.assertNotEqual(b.pk, s.pk)
# Low-level test for related_val
self.assertEqual(s.titles.related_val, (s.id,))
# Higher level test for correct query values (title foof not
# accidentally found).
self.assertSequenceEqual(s.titles.all(), [])
def test_create_diamond_mti_default_pk(self):
# 1 INSERT for each base.
with self.assertNumQueries(4):
common_child = CommonChild.objects.create()
# 3 SELECTs for the parents, 1 UPDATE for the child.
with self.assertNumQueries(4):
common_child.save()
def test_create_diamond_mti_common_parent(self):
with self.assertNumQueries(4):
italian_restaurant_child = ItalianRestaurantCommonParent.objects.create(
name="Ristorante Miron",
address="1234 W. Ash",
)
self.assertEqual(
italian_restaurant_child.italianrestaurant_ptr.place_ptr,
italian_restaurant_child.place_ptr_two,
)
self.assertEqual(
italian_restaurant_child.italianrestaurant_ptr.restaurant_ptr,
italian_restaurant_child.restaurant_ptr,
)
self.assertEqual(
italian_restaurant_child.restaurant_ptr.place_ptr,
italian_restaurant_child.place_ptr_two,
)
self.assertEqual(italian_restaurant_child.name, "Ristorante Miron")
self.assertEqual(italian_restaurant_child.address, "1234 W. Ash")
def test_update_parent_filtering(self):
"""
Updating a field of a model subclass doesn't issue an UPDATE
query constrained by an inner query (#10399).
"""
supplier = Supplier.objects.create(
name="Central market",
address="610 some street",
)
# Capture the expected query in a database agnostic way
with CaptureQueriesContext(connection) as captured_queries:
Place.objects.filter(pk=supplier.pk).update(name=supplier.name)
expected_sql = captured_queries[0]["sql"]
# Capture the queries executed when a subclassed model instance is
# saved.
with CaptureQueriesContext(connection) as captured_queries:
supplier.save(update_fields=("name",))
for query in captured_queries:
sql = query["sql"]
if "UPDATE" in sql:
self.assertEqual(expected_sql, sql)
def test_create_child_no_update(self):
"""Creating a child with non-abstract parents only issues INSERTs."""
def a():
GrandChild.objects.create(
email="grand_parent@example.com",
first_name="grand",
last_name="parent",
)
def b():
GrandChild().save()
for i, test in enumerate([a, b]):
with (
self.subTest(i=i),
self.assertNumQueries(4),
CaptureQueriesContext(connection) as queries,
):
test()
for query in queries:
sql = query["sql"]
self.assertIn("INSERT INTO", sql, sql)
def test_create_copy_with_inherited_m2m(self):
restaurant = Restaurant.objects.create()
supplier = CustomSupplier.objects.create(
name="Central market", address="944 W. Fullerton"
)
supplier.customers.set([restaurant])
old_customers = supplier.customers.all()
supplier.pk = None
supplier.id = None
supplier._state.adding = True
supplier.save()
supplier.customers.set(old_customers)
supplier = Supplier.objects.get(pk=supplier.pk)
self.assertCountEqual(supplier.customers.all(), old_customers)
self.assertSequenceEqual(supplier.customers.all(), [restaurant])
def test_eq(self):
# Equality doesn't transfer in multitable inheritance.
self.assertNotEqual(Place(id=1), Restaurant(id=1))
self.assertNotEqual(Restaurant(id=1), Place(id=1))
def test_mixin_init(self):
m = MixinModel()
self.assertEqual(m.other_attr, 1)
@isolate_apps("model_inheritance")
def test_abstract_parent_link(self):
class A(models.Model):
pass
class B(A):
a = models.OneToOneField("A", parent_link=True, on_delete=models.CASCADE)
class Meta:
abstract = True
class C(B):
pass
self.assertIs(C._meta.parents[A], C._meta.get_field("a"))
@isolate_apps("model_inheritance")
def test_init_subclass(self):
saved_kwargs = {}
class A(models.Model):
def __init_subclass__(cls, **kwargs):
super().__init_subclass__()
saved_kwargs.update(kwargs)
kwargs = {"x": 1, "y": 2, "z": 3}
class B(A, **kwargs):
pass
self.assertEqual(saved_kwargs, kwargs)
@isolate_apps("model_inheritance")
def test_set_name(self):
class ClassAttr:
called = None
def __set_name__(self_, owner, name):
self.assertIsNone(self_.called)
self_.called = (owner, name)
class A(models.Model):
attr = ClassAttr()
self.assertEqual(A.attr.called, (A, "attr"))
def test_inherited_ordering_pk_desc(self):
p1 = Parent.objects.create(first_name="Joe", email="joe@email.com")
p2 = Parent.objects.create(first_name="Jon", email="jon@email.com")
expected_order_by_sql = "ORDER BY %s.%s DESC" % (
connection.ops.quote_name(Parent._meta.db_table),
connection.ops.quote_name(Parent._meta.get_field("grandparent_ptr").column),
)
qs = Parent.objects.all()
self.assertSequenceEqual(qs, [p2, p1])
self.assertIn(expected_order_by_sql, str(qs.query))
def test_queryset_class_getitem(self):
self.assertIs(models.QuerySet[Post], models.QuerySet)
self.assertIs(models.QuerySet[Post, Post], models.QuerySet)
self.assertIs(models.QuerySet[Post, int, str], models.QuerySet)
def test_shadow_parent_attribute_with_field(self):
class ScalarParent(models.Model):
foo = 1
class ScalarOverride(ScalarParent):
foo = models.IntegerField()
self.assertEqual(type(ScalarOverride.foo), DeferredAttribute)
def test_shadow_parent_property_with_field(self):
class PropertyParent(models.Model):
@property
def foo(self):
pass
class PropertyOverride(PropertyParent):
foo = models.IntegerField()
self.assertEqual(type(PropertyOverride.foo), DeferredAttribute)
def test_shadow_parent_method_with_field(self):
class MethodParent(models.Model):
def foo(self):
pass
class MethodOverride(MethodParent):
foo = models.IntegerField()
self.assertEqual(type(MethodOverride.foo), DeferredAttribute)
def test_full_clean(self):
restaurant = Restaurant.objects.create()
with self.assertNumQueries(0), self.assertRaises(ValidationError):
restaurant.full_clean()
class ModelInheritanceDataTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.restaurant = Restaurant.objects.create(
name="Demon Dogs",
address="944 W. Fullerton",
serves_hot_dogs=True,
serves_pizza=False,
rating=2,
)
chef = Chef.objects.create(name="Albert")
cls.italian_restaurant = ItalianRestaurant.objects.create(
name="Ristorante Miron",
address="1234 W. Ash",
serves_hot_dogs=False,
serves_pizza=False,
serves_gnocchi=True,
rating=4,
chef=chef,
)
def test_filter_inherited_model(self):
self.assertQuerySetEqual(
ItalianRestaurant.objects.filter(address="1234 W. Ash"),
[
"Ristorante Miron",
],
attrgetter("name"),
)
def test_update_inherited_model(self):
self.italian_restaurant.address = "1234 W. Elm"
self.italian_restaurant.save()
self.assertQuerySetEqual(
ItalianRestaurant.objects.filter(address="1234 W. Elm"),
[
"Ristorante Miron",
],
attrgetter("name"),
)
def test_parent_fields_available_for_filtering_in_child_model(self):
# Parent fields can be used directly in filters on the child model.
self.assertQuerySetEqual(
Restaurant.objects.filter(name="Demon Dogs"),
[
"Demon Dogs",
],
attrgetter("name"),
)
self.assertQuerySetEqual(
ItalianRestaurant.objects.filter(address="1234 W. Ash"),
[
"Ristorante Miron",
],
attrgetter("name"),
)
def test_filter_on_parent_returns_object_of_parent_type(self):
# Filters against the parent model return objects of the parent's type.
p = Place.objects.get(name="Demon Dogs")
self.assertIs(type(p), Place)
def test_parent_child_one_to_one_link(self):
# Since the parent and child are linked by an automatically created
# OneToOneField, you can get from the parent to the child by using the
# child's name.
self.assertEqual(
Place.objects.get(name="Demon Dogs").restaurant,
Restaurant.objects.get(name="Demon Dogs"),
)
self.assertEqual(
Place.objects.get(name="Ristorante Miron").restaurant.italianrestaurant,
ItalianRestaurant.objects.get(name="Ristorante Miron"),
)
self.assertEqual(
Restaurant.objects.get(name="Ristorante Miron").italianrestaurant,
ItalianRestaurant.objects.get(name="Ristorante Miron"),
)
def test_parent_child_one_to_one_link_on_nonrelated_objects(self):
# This won't work because the Demon Dogs restaurant is not an Italian
# restaurant.
with self.assertRaises(ItalianRestaurant.DoesNotExist):
Place.objects.get(name="Demon Dogs").restaurant.italianrestaurant
def test_inherited_does_not_exist_exception(self):
# An ItalianRestaurant which does not exist is also a Place which does
# not exist.
with self.assertRaises(Place.DoesNotExist):
ItalianRestaurant.objects.get(name="The Noodle Void")
def test_inherited_multiple_objects_returned_exception(self):
# MultipleObjectsReturned is also inherited.
with self.assertRaises(Place.MultipleObjectsReturned):
Restaurant.objects.get()
def test_related_objects_for_inherited_models(self):
# Related objects work just as they normally do.
s1 = Supplier.objects.create(name="Joe's Chickens", address="123 Sesame St")
s1.customers.set([self.restaurant, self.italian_restaurant])
s2 = Supplier.objects.create(name="Luigi's Pasta", address="456 Sesame St")
s2.customers.set([self.italian_restaurant])
# This won't work because the Place we select is not a Restaurant (it's
# a Supplier).
p = Place.objects.get(name="Joe's Chickens")
with self.assertRaises(Restaurant.DoesNotExist):
p.restaurant
self.assertEqual(p.supplier, s1)
self.assertQuerySetEqual(
self.italian_restaurant.provider.order_by("-name"),
["Luigi's Pasta", "Joe's Chickens"],
attrgetter("name"),
)
self.assertQuerySetEqual(
Restaurant.objects.filter(provider__name__contains="Chickens"),
[
"Ristorante Miron",
"Demon Dogs",
],
attrgetter("name"),
)
self.assertQuerySetEqual(
ItalianRestaurant.objects.filter(provider__name__contains="Chickens"),
[
"Ristorante Miron",
],
attrgetter("name"),
)
ParkingLot.objects.create(name="Main St", address="111 Main St", main_site=s1)
ParkingLot.objects.create(
name="Well Lit", address="124 Sesame St", main_site=self.italian_restaurant
)
self.assertEqual(
Restaurant.objects.get(lot__name="Well Lit").name, "Ristorante Miron"
)
def test_update_works_on_parent_and_child_models_at_once(self):
# The update() command can update fields in parent and child classes at
# once (although it executed multiple SQL queries to do so).
rows = Restaurant.objects.filter(
serves_hot_dogs=True, name__contains="D"
).update(name="Demon Puppies", serves_hot_dogs=False)
self.assertEqual(rows, 1)
r1 = Restaurant.objects.get(pk=self.restaurant.pk)
self.assertFalse(r1.serves_hot_dogs)
self.assertEqual(r1.name, "Demon Puppies")
def test_values_works_on_parent_model_fields(self):
# The values() command also works on fields from parent models.
self.assertSequenceEqual(
ItalianRestaurant.objects.values("name", "rating"),
[
{"rating": 4, "name": "Ristorante Miron"},
],
)
def test_select_related_works_on_parent_model_fields(self):
# select_related works with fields from the parent object as if they
# were a normal part of the model.
self.assertNumQueries(2, lambda: ItalianRestaurant.objects.all()[0].chef)
self.assertNumQueries(
1, lambda: ItalianRestaurant.objects.select_related("chef")[0].chef
)
def test_select_related_defer(self):
"""
#23370 - Should be able to defer child fields when using
select_related() from parent to child.
"""
qs = (
Restaurant.objects.select_related("italianrestaurant")
.defer("italianrestaurant__serves_gnocchi")
.order_by("rating")
)
# The field was actually deferred
with self.assertNumQueries(2):
objs = list(qs.all())
self.assertTrue(objs[1].italianrestaurant.serves_gnocchi)
# Model fields where assigned correct values
self.assertEqual(qs[0].name, "Demon Dogs")
self.assertEqual(qs[0].rating, 2)
self.assertEqual(qs[1].italianrestaurant.name, "Ristorante Miron")
self.assertEqual(qs[1].italianrestaurant.rating, 4)
def test_parent_cache_reuse(self):
place = Place.objects.create()
GrandChild.objects.create(place=place)
grand_parent = GrandParent.objects.latest("pk")
with self.assertNumQueries(1):
self.assertEqual(grand_parent.place, place)
parent = grand_parent.parent
with self.assertNumQueries(0):
self.assertEqual(parent.place, place)
child = parent.child
with self.assertNumQueries(0):
self.assertEqual(child.place, place)
grandchild = child.grandchild
with self.assertNumQueries(0):
self.assertEqual(grandchild.place, place)
def test_update_query_counts(self):
"""
Update queries do not generate unnecessary queries (#18304).
"""
with self.assertNumQueries(3):
self.italian_restaurant.save()
def test_filter_inherited_on_null(self):
# Refs #12567
Supplier.objects.create(
name="Central market",
address="610 some street",
)
self.assertQuerySetEqual(
Place.objects.filter(supplier__isnull=False),
[
"Central market",
],
attrgetter("name"),
)
self.assertQuerySetEqual(
Place.objects.filter(supplier__isnull=True).order_by("name"),
[
"Demon Dogs",
"Ristorante Miron",
],
attrgetter("name"),
)
def test_exclude_inherited_on_null(self):
# Refs #12567
Supplier.objects.create(
name="Central market",
address="610 some street",
)
self.assertQuerySetEqual(
Place.objects.exclude(supplier__isnull=False).order_by("name"),
[
"Demon Dogs",
"Ristorante Miron",
],
attrgetter("name"),
)
self.assertQuerySetEqual(
Place.objects.exclude(supplier__isnull=True),
[
"Central market",
],
attrgetter("name"),
)
@isolate_apps("model_inheritance", "model_inheritance.tests")
class InheritanceSameModelNameTests(SimpleTestCase):
def test_abstract_fk_related_name(self):
related_name = "%(app_label)s_%(class)s_references"
class Referenced(models.Model):
class Meta:
app_label = "model_inheritance"
class AbstractReferent(models.Model):
reference = models.ForeignKey(
Referenced, models.CASCADE, related_name=related_name
)
class Meta:
app_label = "model_inheritance"
abstract = True
class Referent(AbstractReferent):
class Meta:
app_label = "model_inheritance"
LocalReferent = Referent
class Referent(AbstractReferent):
class Meta:
app_label = "tests"
ForeignReferent = Referent
self.assertFalse(hasattr(Referenced, related_name))
self.assertIs(
Referenced.model_inheritance_referent_references.field.model, LocalReferent
)
self.assertIs(Referenced.tests_referent_references.field.model, ForeignReferent)
class InheritanceUniqueTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.grand_parent = GrandParent.objects.create(
email="grand_parent@example.com",
first_name="grand",
last_name="parent",
)
def test_unique(self):
grand_child = GrandChild(
email=self.grand_parent.email,
first_name="grand",
last_name="child",
)
msg = "Grand parent with this Email already exists."
with self.assertRaisesMessage(ValidationError, msg):
grand_child.validate_unique()
def test_unique_together(self):
grand_child = GrandChild(
email="grand_child@example.com",
first_name=self.grand_parent.first_name,
last_name=self.grand_parent.last_name,
)
msg = "Grand parent with this First name and Last name already exists."
with self.assertRaisesMessage(ValidationError, msg):
grand_child.validate_unique()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/views.py | tests/middleware/views.py | import json
import sys
from django.http import HttpResponse
from django.middleware.csp import get_nonce
from django.utils.csp import CSP
from django.utils.decorators import method_decorator
from django.views.debug import technical_500_response
from django.views.decorators.common import no_append_slash
from django.views.decorators.csp import csp_override, csp_report_only_override
from django.views.decorators.csrf import csrf_exempt
from django.views.generic import View
def empty_view(request, *args, **kwargs):
return HttpResponse()
@no_append_slash
def sensitive_fbv(request, *args, **kwargs):
return HttpResponse()
@method_decorator(no_append_slash, name="dispatch")
class SensitiveCBV(View):
def get(self, *args, **kwargs):
return HttpResponse()
def csp_nonce(request):
return HttpResponse(get_nonce(request))
@csp_override({})
def csp_disabled_enforced(request):
return HttpResponse()
@csp_report_only_override({})
def csp_disabled_ro(request):
return HttpResponse()
@csp_override({})
@csp_report_only_override({})
def csp_disabled_both(request):
return HttpResponse()
csp_policy_override = {
"default-src": [CSP.SELF],
"img-src": [CSP.SELF, "data:"],
}
@csp_override(csp_policy_override)
def csp_override_enforced(request):
return HttpResponse()
@csp_report_only_override(csp_policy_override)
def csp_override_report_only(request):
return HttpResponse()
@csp_override(csp_policy_override)
@csp_report_only_override(csp_policy_override)
def csp_override_both(request):
return HttpResponse()
def csp_500(request):
try:
raise Exception
except Exception:
return technical_500_response(request, *sys.exc_info())
csp_reports = []
@csrf_exempt
def csp_report_view(request):
if request.method == "POST":
data = json.loads(request.body)
csp_reports.append(data)
return HttpResponse(status=204)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/cond_get_urls.py | tests/middleware/cond_get_urls.py | from django.http import HttpResponse
from django.urls import path
urlpatterns = [
path("", lambda request: HttpResponse("root is here")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/test_csp.py | tests/middleware/test_csp.py | import time
from utils_tests.test_csp import basic_config, basic_policy
from django.contrib.staticfiles.testing import StaticLiveServerTestCase
from django.test import SimpleTestCase
from django.test.selenium import SeleniumTestCase
from django.test.utils import modify_settings, override_settings
from django.utils.csp import CSP
from .views import csp_reports
@override_settings(
MIDDLEWARE=["django.middleware.csp.ContentSecurityPolicyMiddleware"],
ROOT_URLCONF="middleware.urls",
)
class CSPMiddlewareTest(SimpleTestCase):
@override_settings(SECURE_CSP=None, SECURE_CSP_REPORT_ONLY=None)
def test_csp_defaults_off(self):
response = self.client.get("/csp-base/")
self.assertNotIn(CSP.HEADER_ENFORCE, response)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
@override_settings(SECURE_CSP=basic_config, SECURE_CSP_REPORT_ONLY=None)
def test_csp_basic(self):
"""
With SECURE_CSP set to a valid value, the middleware adds a
"Content-Security-Policy" header to the response.
"""
response = self.client.get("/csp-base/")
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
@override_settings(SECURE_CSP={"default-src": [CSP.SELF, CSP.NONCE]})
def test_csp_basic_with_nonce(self):
"""
Test the nonce is added to the header and matches what is in the view.
"""
response = self.client.get("/csp-nonce/")
nonce = response.text
self.assertTrue(nonce)
self.assertEqual(
response[CSP.HEADER_ENFORCE], f"default-src 'self' 'nonce-{nonce}'"
)
@override_settings(SECURE_CSP={"default-src": [CSP.SELF, CSP.NONCE]})
def test_csp_basic_with_nonce_but_unused(self):
"""
Test if `request.csp_nonce` is never accessed, it is not added to the
header.
"""
response = self.client.get("/csp-base/")
nonce = response.text
self.assertIsNotNone(nonce)
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
@override_settings(SECURE_CSP=None, SECURE_CSP_REPORT_ONLY=basic_config)
def test_csp_report_only_basic(self):
"""
With SECURE_CSP_REPORT_ONLY set to a valid value, the middleware adds a
"Content-Security-Policy-Report-Only" header to the response.
"""
response = self.client.get("/csp-base/")
self.assertEqual(response[CSP.HEADER_REPORT_ONLY], basic_policy)
self.assertNotIn(CSP.HEADER_ENFORCE, response)
@override_settings(
SECURE_CSP=basic_config,
SECURE_CSP_REPORT_ONLY=basic_config,
)
def test_csp_both(self):
"""
If both SECURE_CSP and SECURE_CSP_REPORT_ONLY are set, the middleware
adds both headers to the response.
"""
response = self.client.get("/csp-base/")
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
self.assertEqual(response[CSP.HEADER_REPORT_ONLY], basic_policy)
@override_settings(
DEBUG=True,
SECURE_CSP=basic_config,
SECURE_CSP_REPORT_ONLY=basic_config,
)
def test_csp_404_debug_view(self):
"""
Test that the CSP headers are not added to the debug view.
"""
response = self.client.get("/csp-404/")
self.assertNotIn(CSP.HEADER_ENFORCE, response)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
@override_settings(
DEBUG=True,
SECURE_CSP=basic_config,
SECURE_CSP_REPORT_ONLY=basic_config,
)
def test_csp_500_debug_view(self):
"""
Test that the CSP headers are not added to the debug view.
"""
with self.assertLogs("django.request", "WARNING"):
response = self.client.get("/csp-500/")
self.assertNotIn(CSP.HEADER_ENFORCE, response)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
@override_settings(
MIDDLEWARE=["django.middleware.csp.ContentSecurityPolicyMiddleware"],
ROOT_URLCONF="middleware.urls",
SECURE_CSP=basic_config,
SECURE_CSP_REPORT_ONLY=basic_config,
)
class CSPMiddlewareWithDecoratedViewsTest(SimpleTestCase):
def test_no_decorators(self):
response = self.client.get("/csp-base/")
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
self.assertEqual(response[CSP.HEADER_REPORT_ONLY], basic_policy)
def test_csp_disabled_enforced(self):
"""
`csp_override({})` only disables the enforced CSP header.
"""
response = self.client.get("/csp-disabled-enforced/")
self.assertNotIn(CSP.HEADER_ENFORCE, response)
self.assertEqual(response[CSP.HEADER_REPORT_ONLY], basic_policy)
def test_csp_report_only_disabled(self):
"""
`csp_report_only_override({})` only disables the report-only header.
"""
response = self.client.get("/csp-disabled-report-only/")
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
def test_csp_disabled_both(self):
"""
Using both CSP decorators with empty mappings will clear both headers.
"""
response = self.client.get("/csp-disabled-both/")
self.assertNotIn(CSP.HEADER_ENFORCE, response)
self.assertNotIn(CSP.HEADER_REPORT_ONLY, response)
def test_csp_override_enforced(self):
"""
`csp_override` only overrides the enforced header.
"""
response = self.client.get("/csp-override-enforced/")
self.assertEqual(
response[CSP.HEADER_ENFORCE], "default-src 'self'; img-src 'self' data:"
)
self.assertEqual(response[CSP.HEADER_REPORT_ONLY], basic_policy)
def test_csp_report_only_override(self):
"""
`csp_report_only_override` only overrides the report-only header.
"""
response = self.client.get("/csp-override-report-only/")
self.assertEqual(
response[CSP.HEADER_REPORT_ONLY], "default-src 'self'; img-src 'self' data:"
)
self.assertEqual(response[CSP.HEADER_ENFORCE], basic_policy)
def test_csp_override_both_decorator(self):
"""
Using both CSP decorators overrides both CSP Django settings.
"""
response = self.client.get("/csp-override-both/")
self.assertEqual(
response[CSP.HEADER_ENFORCE], "default-src 'self'; img-src 'self' data:"
)
self.assertEqual(
response[CSP.HEADER_REPORT_ONLY], "default-src 'self'; img-src 'self' data:"
)
@override_settings(
ROOT_URLCONF="middleware.urls",
SECURE_CSP_REPORT_ONLY={
"default-src": [CSP.NONE],
"img-src": [CSP.SELF],
"script-src": [CSP.SELF],
"style-src": [CSP.SELF],
"report-uri": "/csp-report/",
},
)
@modify_settings(
MIDDLEWARE={"append": "django.middleware.csp.ContentSecurityPolicyMiddleware"}
)
class CSPSeleniumTestCase(SeleniumTestCase, StaticLiveServerTestCase):
available_apps = ["middleware"]
def setUp(self):
self.addCleanup(csp_reports.clear)
super().setUp()
def test_reports_are_generated(self):
url = self.live_server_url + "/csp-failure/"
self.selenium.get(url)
time.sleep(1) # Allow time for the CSP report to be sent.
reports = sorted(
(r["csp-report"]["document-uri"], r["csp-report"]["violated-directive"])
for r in csp_reports
)
self.assertEqual(reports, [(url, "img-src"), (url, "style-src-elem")])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/extra_urls.py | tests/middleware/extra_urls.py | from django.urls import path
from . import views
urlpatterns = [
path("customurlconf/noslash", views.empty_view),
path("customurlconf/slash/", views.empty_view),
path("customurlconf/needsquoting#/", views.empty_view),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/__init__.py | tests/middleware/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/tests.py | tests/middleware/tests.py | import gzip
import random
import re
import struct
import zlib
from io import BytesIO
from unittest import mock
from urllib.parse import quote
from django.conf import settings
from django.core import mail
from django.core.exceptions import PermissionDenied
from django.http import (
FileResponse,
HttpRequest,
HttpResponse,
HttpResponseNotFound,
HttpResponsePermanentRedirect,
HttpResponseRedirect,
StreamingHttpResponse,
)
from django.middleware.clickjacking import XFrameOptionsMiddleware
from django.middleware.common import BrokenLinkEmailsMiddleware, CommonMiddleware
from django.middleware.gzip import GZipMiddleware
from django.middleware.http import ConditionalGetMiddleware
from django.test import RequestFactory, SimpleTestCase, override_settings
int2byte = struct.Struct(">B").pack
def get_response_empty(request):
return HttpResponse()
def get_response_404(request):
return HttpResponseNotFound()
@override_settings(ROOT_URLCONF="middleware.urls")
class CommonMiddlewareTest(SimpleTestCase):
rf = RequestFactory()
@override_settings(APPEND_SLASH=True)
def test_append_slash_have_slash(self):
"""
URLs with slashes should go unmolested.
"""
request = self.rf.get("/slash/")
self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_slashless_resource(self):
"""
Matches to explicit slashless URLs should go unmolested.
"""
def get_response(req):
return HttpResponse("Here's the text of the web page.")
request = self.rf.get("/noslash")
self.assertIsNone(CommonMiddleware(get_response).process_request(request))
self.assertEqual(
CommonMiddleware(get_response)(request).content,
b"Here's the text of the web page.",
)
@override_settings(APPEND_SLASH=True)
def test_append_slash_slashless_unknown(self):
"""
APPEND_SLASH should not redirect to unknown resources.
"""
request = self.rf.get("/unknown")
response = CommonMiddleware(get_response_404)(request)
self.assertEqual(response.status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_redirect(self):
"""
APPEND_SLASH should redirect slashless URLs to a valid pattern.
"""
request = self.rf.get("/slash")
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertIsNone(r)
response = HttpResponseNotFound()
r = CommonMiddleware(get_response_empty).process_response(request, response)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/slash/")
@override_settings(APPEND_SLASH=True)
def test_append_slash_redirect_querystring(self):
"""
APPEND_SLASH should preserve querystrings when redirecting.
"""
request = self.rf.get("/slash?test=1")
resp = CommonMiddleware(get_response_404)(request)
self.assertEqual(resp.url, "/slash/?test=1")
@override_settings(APPEND_SLASH=True)
def test_append_slash_redirect_querystring_have_slash(self):
"""
APPEND_SLASH should append slash to path when redirecting a request
with a querystring ending with slash.
"""
request = self.rf.get("/slash?test=slash/")
resp = CommonMiddleware(get_response_404)(request)
self.assertIsInstance(resp, HttpResponsePermanentRedirect)
self.assertEqual(resp.url, "/slash/?test=slash/")
@override_settings(APPEND_SLASH=True, DEBUG=True)
def test_append_slash_no_redirect_in_DEBUG(self):
"""
While in debug mode, an exception is raised with a warning
when a failed attempt is made to DELETE, POST, PUT, or PATCH to an URL
which would normally be redirected to a slashed version.
"""
msg = "maintaining %s data. Change your form to point to testserver/slash/"
request = self.rf.get("/slash")
request.method = "POST"
with self.assertRaisesMessage(RuntimeError, msg % request.method):
CommonMiddleware(get_response_404)(request)
request = self.rf.get("/slash")
request.method = "PUT"
with self.assertRaisesMessage(RuntimeError, msg % request.method):
CommonMiddleware(get_response_404)(request)
request = self.rf.get("/slash")
request.method = "PATCH"
with self.assertRaisesMessage(RuntimeError, msg % request.method):
CommonMiddleware(get_response_404)(request)
request = self.rf.delete("/slash")
with self.assertRaisesMessage(RuntimeError, msg % request.method):
CommonMiddleware(get_response_404)(request)
@override_settings(APPEND_SLASH=False)
def test_append_slash_disabled(self):
"""
Disabling append slash functionality should leave slashless URLs alone.
"""
request = self.rf.get("/slash")
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_opt_out(self):
"""
Views marked with @no_append_slash should be left alone.
"""
request = self.rf.get("/sensitive_fbv")
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
request = self.rf.get("/sensitive_cbv")
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_quoted(self):
"""
URLs which require quoting should be redirected to their slash version.
"""
request = self.rf.get(quote("/needsquoting#"))
r = CommonMiddleware(get_response_404)(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/needsquoting%23/")
@override_settings(APPEND_SLASH=True)
def test_append_slash_leading_slashes(self):
"""
Paths starting with two slashes are escaped to prevent open redirects.
If there's a URL pattern that allows paths to start with two slashes, a
request with path //evil.com must not redirect to //evil.com/ (appended
slash) which is a schemaless absolute URL. The browser would navigate
to evil.com/.
"""
# Use 4 slashes because of RequestFactory behavior.
request = self.rf.get("////evil.com/security")
r = CommonMiddleware(get_response_404).process_request(request)
self.assertIsNone(r)
response = HttpResponseNotFound()
r = CommonMiddleware(get_response_404).process_response(request, response)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/%2Fevil.com/security/")
r = CommonMiddleware(get_response_404)(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/%2Fevil.com/security/")
@override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
def test_prepend_www(self):
request = self.rf.get("/path/")
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/path/")
@override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
def test_prepend_www_append_slash_have_slash(self):
request = self.rf.get("/slash/")
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/slash/")
@override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
def test_prepend_www_append_slash_slashless(self):
request = self.rf.get("/slash")
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/slash/")
# The following tests examine expected behavior given a custom URLconf that
# overrides the default one through the request object.
@override_settings(APPEND_SLASH=True)
def test_append_slash_have_slash_custom_urlconf(self):
"""
URLs with slashes should go unmolested.
"""
request = self.rf.get("/customurlconf/slash/")
request.urlconf = "middleware.extra_urls"
self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_slashless_resource_custom_urlconf(self):
"""
Matches to explicit slashless URLs should go unmolested.
"""
def get_response(req):
return HttpResponse("web content")
request = self.rf.get("/customurlconf/noslash")
request.urlconf = "middleware.extra_urls"
self.assertIsNone(CommonMiddleware(get_response).process_request(request))
self.assertEqual(
CommonMiddleware(get_response)(request).content, b"web content"
)
@override_settings(APPEND_SLASH=True)
def test_append_slash_slashless_unknown_custom_urlconf(self):
"""
APPEND_SLASH should not redirect to unknown resources.
"""
request = self.rf.get("/customurlconf/unknown")
request.urlconf = "middleware.extra_urls"
self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_redirect_custom_urlconf(self):
"""
APPEND_SLASH should redirect slashless URLs to a valid pattern.
"""
request = self.rf.get("/customurlconf/slash")
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_404)(request)
self.assertIsNotNone(
r,
"CommonMiddleware failed to return APPEND_SLASH redirect using "
"request.urlconf",
)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/customurlconf/slash/")
@override_settings(APPEND_SLASH=True, DEBUG=True)
def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self):
"""
While in debug mode, an exception is raised with a warning
when a failed attempt is made to POST to an URL which would normally be
redirected to a slashed version.
"""
request = self.rf.get("/customurlconf/slash")
request.urlconf = "middleware.extra_urls"
request.method = "POST"
with self.assertRaisesMessage(RuntimeError, "end in a slash"):
CommonMiddleware(get_response_404)(request)
@override_settings(APPEND_SLASH=False)
def test_append_slash_disabled_custom_urlconf(self):
"""
Disabling append slash functionality should leave slashless URLs alone.
"""
request = self.rf.get("/customurlconf/slash")
request.urlconf = "middleware.extra_urls"
self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
@override_settings(APPEND_SLASH=True)
def test_append_slash_quoted_custom_urlconf(self):
"""
URLs which require quoting should be redirected to their slash version.
"""
request = self.rf.get(quote("/customurlconf/needsquoting#"))
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_404)(request)
self.assertIsNotNone(
r,
"CommonMiddleware failed to return APPEND_SLASH redirect using "
"request.urlconf",
)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/customurlconf/needsquoting%23/")
@override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
def test_prepend_www_custom_urlconf(self):
request = self.rf.get("/customurlconf/path/")
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/customurlconf/path/")
@override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
def test_prepend_www_append_slash_have_slash_custom_urlconf(self):
request = self.rf.get("/customurlconf/slash/")
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
@override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
def test_prepend_www_append_slash_slashless_custom_urlconf(self):
request = self.rf.get("/customurlconf/slash")
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
# Tests for the Content-Length header
def test_content_length_header_added(self):
def get_response(req):
response = HttpResponse("content")
self.assertNotIn("Content-Length", response)
return response
response = CommonMiddleware(get_response)(self.rf.get("/"))
self.assertEqual(int(response.headers["Content-Length"]), len(response.content))
def test_content_length_header_not_added_for_streaming_response(self):
def get_response(req):
response = StreamingHttpResponse("content")
self.assertNotIn("Content-Length", response)
return response
response = CommonMiddleware(get_response)(self.rf.get("/"))
self.assertNotIn("Content-Length", response)
def test_content_length_header_not_changed(self):
bad_content_length = 500
def get_response(req):
response = HttpResponse()
response.headers["Content-Length"] = bad_content_length
return response
response = CommonMiddleware(get_response)(self.rf.get("/"))
self.assertEqual(int(response.headers["Content-Length"]), bad_content_length)
@override_settings(APPEND_SLASH=True)
def test_content_length_header_added_to_append_slash_redirect(self):
"""
The Content-Length header is set when redirecting with the APPEND_SLASH
setting.
"""
request = self.rf.get("/customurlconf/slash")
request.urlconf = "middleware.extra_urls"
r = CommonMiddleware(get_response_404)(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/customurlconf/slash/")
self.assertTrue(r.has_header("Content-Length"))
# Other tests
@override_settings(DISALLOWED_USER_AGENTS=[re.compile(r"foo")])
def test_disallowed_user_agents(self):
request = self.rf.get("/slash")
request.META["HTTP_USER_AGENT"] = "foo"
with self.assertRaisesMessage(PermissionDenied, "Forbidden user agent"):
CommonMiddleware(get_response_empty).process_request(request)
def test_non_ascii_query_string_does_not_crash(self):
"""Regression test for #15152"""
request = self.rf.get("/slash")
request.META["QUERY_STRING"] = "drink=café"
r = CommonMiddleware(get_response_empty).process_request(request)
self.assertIsNone(r)
response = HttpResponseNotFound()
r = CommonMiddleware(get_response_empty).process_response(request, response)
self.assertEqual(r.status_code, 301)
def test_response_redirect_class(self):
request = self.rf.get("/slash")
r = CommonMiddleware(get_response_404)(request)
self.assertEqual(r.status_code, 301)
self.assertEqual(r.url, "/slash/")
self.assertIsInstance(r, HttpResponsePermanentRedirect)
def test_response_redirect_class_subclass(self):
class MyCommonMiddleware(CommonMiddleware):
response_redirect_class = HttpResponseRedirect
request = self.rf.get("/slash")
r = MyCommonMiddleware(get_response_404)(request)
self.assertEqual(r.status_code, 302)
self.assertEqual(r.url, "/slash/")
self.assertIsInstance(r, HttpResponseRedirect)
@override_settings(
IGNORABLE_404_URLS=[re.compile(r"foo")],
MANAGERS=["manager@example.com"],
)
class BrokenLinkEmailsMiddlewareTest(SimpleTestCase):
rf = RequestFactory()
def setUp(self):
self.req = self.rf.get("/regular_url/that/does/not/exist")
def get_response(self, req):
return self.client.get(req.path)
def test_404_error_reporting(self):
self.req.META["HTTP_REFERER"] = "/another/url/"
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 1)
self.assertIn("Broken", mail.outbox[0].subject)
def test_404_error_reporting_no_referer(self):
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
def test_404_error_reporting_ignored_url(self):
self.req.path = self.req.path_info = "foo_url/that/does/not/exist"
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
def test_custom_request_checker(self):
class SubclassedMiddleware(BrokenLinkEmailsMiddleware):
ignored_user_agent_patterns = (
re.compile(r"Spider.*"),
re.compile(r"Robot.*"),
)
def is_ignorable_request(self, request, uri, domain, referer):
"""Check user-agent in addition to normal checks."""
if super().is_ignorable_request(request, uri, domain, referer):
return True
user_agent = request.META["HTTP_USER_AGENT"]
return any(
pattern.search(user_agent)
for pattern in self.ignored_user_agent_patterns
)
self.req.META["HTTP_REFERER"] = "/another/url/"
self.req.META["HTTP_USER_AGENT"] = "Spider machine 3.4"
SubclassedMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
self.req.META["HTTP_USER_AGENT"] = "My user agent"
SubclassedMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 1)
def test_referer_equal_to_requested_url(self):
"""
Some bots set the referer to the current URL to avoid being blocked by
an referer check (#25302).
"""
self.req.META["HTTP_REFERER"] = self.req.path
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
# URL with scheme and domain should also be ignored
self.req.META["HTTP_REFERER"] = "http://testserver%s" % self.req.path
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
# URL with a different scheme should be ignored as well because bots
# tend to use http:// in referers even when browsing HTTPS websites.
self.req.META["HTTP_X_PROTO"] = "https"
self.req.META["SERVER_PORT"] = 443
with self.settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_PROTO", "https")):
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
def test_referer_equal_to_requested_url_on_another_domain(self):
self.req.META["HTTP_REFERER"] = "http://anotherserver%s" % self.req.path
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 1)
@override_settings(APPEND_SLASH=True)
def test_referer_equal_to_requested_url_without_trailing_slash_with_append_slash(
self,
):
self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 0)
@override_settings(APPEND_SLASH=False)
def test_referer_equal_to_requested_url_without_trailing_slash_with_no_append_slash(
self,
):
self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
BrokenLinkEmailsMiddleware(self.get_response)(self.req)
self.assertEqual(len(mail.outbox), 1)
@override_settings(ROOT_URLCONF="middleware.cond_get_urls")
class ConditionalGetMiddlewareTest(SimpleTestCase):
request_factory = RequestFactory()
def setUp(self):
self.req = self.request_factory.get("/")
self.resp_headers = {}
def get_response(self, req):
resp = self.client.get(req.path_info)
for key, value in self.resp_headers.items():
resp[key] = value
return resp
# Tests for the ETag header
def test_middleware_calculates_etag(self):
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
self.assertNotEqual("", resp["ETag"])
def test_middleware_wont_overwrite_etag(self):
self.resp_headers["ETag"] = "eggs"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
self.assertEqual("eggs", resp["ETag"])
def test_no_etag_streaming_response(self):
def get_response(req):
return StreamingHttpResponse(["content"])
self.assertFalse(
ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
)
def test_no_etag_response_empty_content(self):
def get_response(req):
return HttpResponse()
self.assertFalse(
ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
)
def test_no_etag_no_store_cache(self):
self.resp_headers["Cache-Control"] = "No-Cache, No-Store, Max-age=0"
self.assertFalse(
ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
)
def test_etag_extended_cache_control(self):
self.resp_headers["Cache-Control"] = 'my-directive="my-no-store"'
self.assertTrue(
ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
)
def test_if_none_match_and_no_etag(self):
self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
def test_no_if_none_match_and_etag(self):
self.resp_headers["ETag"] = "eggs"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
def test_if_none_match_and_same_etag(self):
self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
self.resp_headers["ETag"] = '"spam"'
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 304)
def test_if_none_match_and_different_etag(self):
self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
self.resp_headers["ETag"] = "eggs"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
def test_if_none_match_and_redirect(self):
def get_response(req):
resp = self.client.get(req.path_info)
resp["ETag"] = "spam"
resp["Location"] = "/"
resp.status_code = 301
return resp
self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
resp = ConditionalGetMiddleware(get_response)(self.req)
self.assertEqual(resp.status_code, 301)
def test_if_none_match_and_client_error(self):
def get_response(req):
resp = self.client.get(req.path_info)
resp["ETag"] = "spam"
resp.status_code = 400
return resp
self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
resp = ConditionalGetMiddleware(get_response)(self.req)
self.assertEqual(resp.status_code, 400)
# Tests for the Last-Modified header
def test_if_modified_since_and_no_last_modified(self):
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
def test_no_if_modified_since_and_last_modified(self):
self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 200)
def test_if_modified_since_and_same_last_modified(self):
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(self.resp.status_code, 304)
def test_if_modified_since_and_last_modified_in_the_past(self):
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(resp.status_code, 304)
def test_if_modified_since_and_last_modified_in_the_future(self):
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:41:44 GMT"
self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
self.assertEqual(self.resp.status_code, 200)
def test_if_modified_since_and_redirect(self):
def get_response(req):
resp = self.client.get(req.path_info)
resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
resp["Location"] = "/"
resp.status_code = 301
return resp
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
resp = ConditionalGetMiddleware(get_response)(self.req)
self.assertEqual(resp.status_code, 301)
def test_if_modified_since_and_client_error(self):
def get_response(req):
resp = self.client.get(req.path_info)
resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
resp.status_code = 400
return resp
self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
resp = ConditionalGetMiddleware(get_response)(self.req)
self.assertEqual(resp.status_code, 400)
def test_not_modified_headers(self):
"""
The 304 Not Modified response should include only the headers required
by RFC 9110 Section 15.4.5, Last-Modified, and the cookies.
"""
def get_response(req):
resp = self.client.get(req.path_info)
resp["Date"] = "Sat, 12 Feb 2011 17:35:44 GMT"
resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
resp["Expires"] = "Sun, 13 Feb 2011 17:35:44 GMT"
resp["Vary"] = "Cookie"
resp["Cache-Control"] = "public"
resp["Content-Location"] = "/alt"
resp["Content-Language"] = "en" # shouldn't be preserved
resp["ETag"] = '"spam"'
resp.set_cookie("key", "value")
return resp
self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
new_response = ConditionalGetMiddleware(get_response)(self.req)
self.assertEqual(new_response.status_code, 304)
base_response = get_response(self.req)
for header in (
"Cache-Control",
"Content-Location",
"Date",
"ETag",
"Expires",
"Last-Modified",
"Vary",
):
self.assertEqual(
new_response.headers[header], base_response.headers[header]
)
self.assertEqual(new_response.cookies, base_response.cookies)
self.assertNotIn("Content-Language", new_response)
def test_no_unsafe(self):
"""
ConditionalGetMiddleware shouldn't return a conditional response on an
unsafe request. A response has already been generated by the time
ConditionalGetMiddleware is called, so it's too late to return a 412
Precondition Failed.
"""
def get_200_response(req):
return HttpResponse(status=200)
response = ConditionalGetMiddleware(self.get_response)(self.req)
etag = response.headers["ETag"]
put_request = self.request_factory.put("/", headers={"if-match": etag})
conditional_get_response = ConditionalGetMiddleware(get_200_response)(
put_request
)
self.assertEqual(
conditional_get_response.status_code, 200
) # should never be a 412
def test_no_head(self):
"""
ConditionalGetMiddleware shouldn't compute and return an ETag on a
HEAD request since it can't do so accurately without access to the
response body of the corresponding GET.
"""
def get_200_response(req):
return HttpResponse(status=200)
request = self.request_factory.head("/")
conditional_get_response = ConditionalGetMiddleware(get_200_response)(request)
self.assertNotIn("ETag", conditional_get_response)
class XFrameOptionsMiddlewareTest(SimpleTestCase):
"""
Tests for the X-Frame-Options clickjacking prevention middleware.
"""
def test_same_origin(self):
"""
The X_FRAME_OPTIONS setting can be set to SAMEORIGIN to have the
middleware use that value for the HTTP header.
"""
with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
with override_settings(X_FRAME_OPTIONS="sameorigin"):
r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
def test_deny(self):
"""
The X_FRAME_OPTIONS setting can be set to DENY to have the middleware
use that value for the HTTP header.
"""
with override_settings(X_FRAME_OPTIONS="DENY"):
r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "DENY")
with override_settings(X_FRAME_OPTIONS="deny"):
r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "DENY")
def test_defaults_sameorigin(self):
"""
If the X_FRAME_OPTIONS setting is not set then it defaults to
DENY.
"""
with override_settings(X_FRAME_OPTIONS=None):
del settings.X_FRAME_OPTIONS # restored by override_settings
r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "DENY")
def test_dont_set_if_set(self):
"""
If the X-Frame-Options header is already set then the middleware does
not attempt to override it.
"""
def same_origin_response(request):
response = HttpResponse()
response.headers["X-Frame-Options"] = "SAMEORIGIN"
return response
def deny_response(request):
response = HttpResponse()
response.headers["X-Frame-Options"] = "DENY"
return response
with override_settings(X_FRAME_OPTIONS="DENY"):
r = XFrameOptionsMiddleware(same_origin_response)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
r = XFrameOptionsMiddleware(deny_response)(HttpRequest())
self.assertEqual(r.headers["X-Frame-Options"], "DENY")
def test_response_exempt(self):
"""
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/test_security.py | tests/middleware/test_security.py | from django.http import HttpResponse
from django.test import RequestFactory, SimpleTestCase
from django.test.utils import override_settings
class SecurityMiddlewareTest(SimpleTestCase):
def middleware(self, *args, **kwargs):
from django.middleware.security import SecurityMiddleware
return SecurityMiddleware(self.response(*args, **kwargs))
@property
def secure_request_kwargs(self):
return {"wsgi.url_scheme": "https"}
def response(self, *args, headers=None, **kwargs):
def get_response(req):
response = HttpResponse(*args, **kwargs)
if headers:
for k, v in headers.items():
response.headers[k] = v
return response
return get_response
def process_response(self, *args, secure=False, request=None, **kwargs):
request_kwargs = {}
if secure:
request_kwargs.update(self.secure_request_kwargs)
if request is None:
request = self.request.get("/some/url", **request_kwargs)
ret = self.middleware(*args, **kwargs).process_request(request)
if ret:
return ret
return self.middleware(*args, **kwargs)(request)
request = RequestFactory()
def process_request(self, method, *args, secure=False, **kwargs):
if secure:
kwargs.update(self.secure_request_kwargs)
req = getattr(self.request, method.lower())(*args, **kwargs)
return self.middleware().process_request(req)
@override_settings(SECURE_HSTS_SECONDS=3600)
def test_sts_on(self):
"""
With SECURE_HSTS_SECONDS=3600, the middleware adds
"Strict-Transport-Security: max-age=3600" to the response.
"""
self.assertEqual(
self.process_response(secure=True).headers["Strict-Transport-Security"],
"max-age=3600",
)
@override_settings(SECURE_HSTS_SECONDS=3600)
def test_sts_already_present(self):
"""
The middleware will not override a "Strict-Transport-Security" header
already present in the response.
"""
response = self.process_response(
secure=True, headers={"Strict-Transport-Security": "max-age=7200"}
)
self.assertEqual(response.headers["Strict-Transport-Security"], "max-age=7200")
@override_settings(SECURE_HSTS_SECONDS=3600)
def test_sts_only_if_secure(self):
"""
The "Strict-Transport-Security" header is not added to responses going
over an insecure connection.
"""
self.assertNotIn(
"Strict-Transport-Security",
self.process_response(secure=False).headers,
)
@override_settings(SECURE_HSTS_SECONDS=0)
def test_sts_off(self):
"""
With SECURE_HSTS_SECONDS=0, the middleware does not add a
"Strict-Transport-Security" header to the response.
"""
self.assertNotIn(
"Strict-Transport-Security",
self.process_response(secure=True).headers,
)
@override_settings(SECURE_HSTS_SECONDS=600, SECURE_HSTS_INCLUDE_SUBDOMAINS=True)
def test_sts_include_subdomains(self):
"""
With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_INCLUDE_SUBDOMAINS
True, the middleware adds a "Strict-Transport-Security" header with the
"includeSubDomains" directive to the response.
"""
response = self.process_response(secure=True)
self.assertEqual(
response.headers["Strict-Transport-Security"],
"max-age=600; includeSubDomains",
)
@override_settings(SECURE_HSTS_SECONDS=600, SECURE_HSTS_INCLUDE_SUBDOMAINS=False)
def test_sts_no_include_subdomains(self):
"""
With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_INCLUDE_SUBDOMAINS
False, the middleware adds a "Strict-Transport-Security" header without
the "includeSubDomains" directive to the response.
"""
response = self.process_response(secure=True)
self.assertEqual(response.headers["Strict-Transport-Security"], "max-age=600")
@override_settings(SECURE_HSTS_SECONDS=10886400, SECURE_HSTS_PRELOAD=True)
def test_sts_preload(self):
"""
With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_PRELOAD True, the
middleware adds a "Strict-Transport-Security" header with the "preload"
directive to the response.
"""
response = self.process_response(secure=True)
self.assertEqual(
response.headers["Strict-Transport-Security"],
"max-age=10886400; preload",
)
@override_settings(
SECURE_HSTS_SECONDS=10886400,
SECURE_HSTS_INCLUDE_SUBDOMAINS=True,
SECURE_HSTS_PRELOAD=True,
)
def test_sts_subdomains_and_preload(self):
"""
With SECURE_HSTS_SECONDS non-zero, SECURE_HSTS_INCLUDE_SUBDOMAINS and
SECURE_HSTS_PRELOAD True, the middleware adds a
"Strict-Transport-Security" header containing both the
"includeSubDomains" and "preload" directives to the response.
"""
response = self.process_response(secure=True)
self.assertEqual(
response.headers["Strict-Transport-Security"],
"max-age=10886400; includeSubDomains; preload",
)
@override_settings(SECURE_HSTS_SECONDS=10886400, SECURE_HSTS_PRELOAD=False)
def test_sts_no_preload(self):
"""
With SECURE_HSTS_SECONDS non-zero and SECURE_HSTS_PRELOAD
False, the middleware adds a "Strict-Transport-Security" header without
the "preload" directive to the response.
"""
response = self.process_response(secure=True)
self.assertEqual(
response.headers["Strict-Transport-Security"],
"max-age=10886400",
)
@override_settings(SECURE_CONTENT_TYPE_NOSNIFF=True)
def test_content_type_on(self):
"""
With SECURE_CONTENT_TYPE_NOSNIFF set to True, the middleware adds
"X-Content-Type-Options: nosniff" header to the response.
"""
self.assertEqual(
self.process_response().headers["X-Content-Type-Options"],
"nosniff",
)
@override_settings(SECURE_CONTENT_TYPE_NOSNIFF=True)
def test_content_type_already_present(self):
"""
The middleware will not override an "X-Content-Type-Options" header
already present in the response.
"""
response = self.process_response(
secure=True, headers={"X-Content-Type-Options": "foo"}
)
self.assertEqual(response.headers["X-Content-Type-Options"], "foo")
@override_settings(SECURE_CONTENT_TYPE_NOSNIFF=False)
def test_content_type_off(self):
"""
With SECURE_CONTENT_TYPE_NOSNIFF False, the middleware does not add an
"X-Content-Type-Options" header to the response.
"""
self.assertNotIn("X-Content-Type-Options", self.process_response().headers)
@override_settings(SECURE_SSL_REDIRECT=True)
def test_ssl_redirect_on(self):
"""
With SECURE_SSL_REDIRECT True, the middleware redirects any non-secure
requests to the https:// version of the same URL.
"""
ret = self.process_request("get", "/some/url?query=string")
self.assertEqual(ret.status_code, 301)
self.assertEqual(ret["Location"], "https://testserver/some/url?query=string")
@override_settings(SECURE_SSL_REDIRECT=True)
def test_no_redirect_ssl(self):
"""
The middleware does not redirect secure requests.
"""
ret = self.process_request("get", "/some/url", secure=True)
self.assertIsNone(ret)
@override_settings(SECURE_SSL_REDIRECT=True, SECURE_REDIRECT_EXEMPT=["^insecure/"])
def test_redirect_exempt(self):
"""
The middleware does not redirect requests with URL path matching an
exempt pattern.
"""
ret = self.process_request("get", "/insecure/page")
self.assertIsNone(ret)
@override_settings(SECURE_SSL_REDIRECT=True, SECURE_SSL_HOST="secure.example.com")
def test_redirect_ssl_host(self):
"""
The middleware redirects to SECURE_SSL_HOST if given.
"""
ret = self.process_request("get", "/some/url")
self.assertEqual(ret.status_code, 301)
self.assertEqual(ret["Location"], "https://secure.example.com/some/url")
@override_settings(SECURE_SSL_REDIRECT=False)
def test_ssl_redirect_off(self):
"""
With SECURE_SSL_REDIRECT False, the middleware does not redirect.
"""
ret = self.process_request("get", "/some/url")
self.assertIsNone(ret)
@override_settings(SECURE_REFERRER_POLICY=None)
def test_referrer_policy_off(self):
"""
With SECURE_REFERRER_POLICY set to None, the middleware does not add a
"Referrer-Policy" header to the response.
"""
self.assertNotIn("Referrer-Policy", self.process_response().headers)
def test_referrer_policy_on(self):
"""
With SECURE_REFERRER_POLICY set to a valid value, the middleware adds a
"Referrer-Policy" header to the response.
"""
tests = (
("strict-origin", "strict-origin"),
("strict-origin,origin", "strict-origin,origin"),
("strict-origin, origin", "strict-origin,origin"),
(["strict-origin", "origin"], "strict-origin,origin"),
(("strict-origin", "origin"), "strict-origin,origin"),
)
for value, expected in tests:
with (
self.subTest(value=value),
override_settings(SECURE_REFERRER_POLICY=value),
):
self.assertEqual(
self.process_response().headers["Referrer-Policy"],
expected,
)
@override_settings(SECURE_REFERRER_POLICY="strict-origin")
def test_referrer_policy_already_present(self):
"""
The middleware will not override a "Referrer-Policy" header already
present in the response.
"""
response = self.process_response(headers={"Referrer-Policy": "unsafe-url"})
self.assertEqual(response.headers["Referrer-Policy"], "unsafe-url")
@override_settings(SECURE_CROSS_ORIGIN_OPENER_POLICY=None)
def test_coop_off(self):
"""
With SECURE_CROSS_ORIGIN_OPENER_POLICY set to None, the middleware does
not add a "Cross-Origin-Opener-Policy" header to the response.
"""
self.assertNotIn("Cross-Origin-Opener-Policy", self.process_response())
def test_coop_default(self):
"""SECURE_CROSS_ORIGIN_OPENER_POLICY defaults to same-origin."""
self.assertEqual(
self.process_response().headers["Cross-Origin-Opener-Policy"],
"same-origin",
)
def test_coop_on(self):
"""
With SECURE_CROSS_ORIGIN_OPENER_POLICY set to a valid value, the
middleware adds a "Cross-Origin_Opener-Policy" header to the response.
"""
tests = ["same-origin", "same-origin-allow-popups", "unsafe-none"]
for value in tests:
with (
self.subTest(value=value),
override_settings(
SECURE_CROSS_ORIGIN_OPENER_POLICY=value,
),
):
self.assertEqual(
self.process_response().headers["Cross-Origin-Opener-Policy"],
value,
)
@override_settings(SECURE_CROSS_ORIGIN_OPENER_POLICY="unsafe-none")
def test_coop_already_present(self):
"""
The middleware doesn't override a "Cross-Origin-Opener-Policy" header
already present in the response.
"""
response = self.process_response(
headers={"Cross-Origin-Opener-Policy": "same-origin"}
)
self.assertEqual(response.headers["Cross-Origin-Opener-Policy"], "same-origin")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/middleware/urls.py | tests/middleware/urls.py | from django.urls import path, re_path
from django.views.debug import default_urlconf
from . import views
urlpatterns = [
path("noslash", views.empty_view),
path("slash/", views.empty_view),
path("needsquoting#/", views.empty_view),
# Accepts paths with two leading slashes.
re_path(r"^(.+)/security/$", views.empty_view),
# Should not append slash.
path("sensitive_fbv/", views.sensitive_fbv),
path("sensitive_cbv/", views.SensitiveCBV.as_view()),
# Used in CSP tests.
path("csp-failure/", default_urlconf),
path("csp-report/", views.csp_report_view),
path("csp-base/", views.empty_view),
path("csp-nonce/", views.csp_nonce),
path("csp-disabled-both/", views.csp_disabled_both),
path("csp-disabled-enforced/", views.csp_disabled_enforced),
path("csp-disabled-report-only/", views.csp_disabled_ro),
path("csp-override-both/", views.csp_override_both),
path("csp-override-enforced/", views.csp_override_enforced),
path("csp-override-report-only/", views.csp_override_report_only),
path("csp-500/", views.csp_500),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/fixtures/models.py | tests/fixtures/models.py | """
Fixtures.
Fixtures are a way of loading data into the database in bulk. Fixure data
can be stored in any serializable format (including JSON and XML). Fixtures
are identified by name, and are stored in either a directory named 'fixtures'
in the application directory, or in one of the directories named in the
``FIXTURE_DIRS`` setting.
"""
import uuid
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models
class Category(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
class Meta:
ordering = ("title",)
def __str__(self):
return self.title
class Article(models.Model):
headline = models.CharField(max_length=100, default="Default headline")
pub_date = models.DateTimeField()
class Meta:
ordering = ("-pub_date", "headline")
def __str__(self):
return self.headline
class Blog(models.Model):
name = models.CharField(max_length=100)
featured = models.ForeignKey(
Article, models.CASCADE, related_name="fixtures_featured_set"
)
articles = models.ManyToManyField(
Article, blank=True, related_name="fixtures_articles_set"
)
def __str__(self):
return self.name
class Tag(models.Model):
name = models.CharField(max_length=100)
tagged_type = models.ForeignKey(
ContentType, models.CASCADE, related_name="fixtures_tag_set"
)
tagged_id = models.PositiveIntegerField(default=0)
tagged = GenericForeignKey(ct_field="tagged_type", fk_field="tagged_id")
def __str__(self):
return '<%s: %s> tagged "%s"' % (
self.tagged.__class__.__name__,
self.tagged,
self.name,
)
class PersonManager(models.Manager):
def get_by_natural_key(self, name):
return self.get(name=name)
class Person(models.Model):
objects = PersonManager()
name = models.CharField(max_length=100, unique=True)
class Meta:
ordering = ("name",)
def __str__(self):
return self.name
def natural_key(self):
return (self.name,)
class SpyManager(PersonManager):
def get_queryset(self):
return super().get_queryset().filter(cover_blown=False)
class Spy(Person):
objects = SpyManager()
cover_blown = models.BooleanField(default=False)
class ProxySpy(Spy):
class Meta:
proxy = True
class VisaManager(models.Manager):
def get_queryset(self):
return super().get_queryset().prefetch_related("permissions")
class Visa(models.Model):
person = models.ForeignKey(Person, models.CASCADE)
permissions = models.ManyToManyField(Permission, blank=True)
objects = VisaManager()
def __str__(self):
return "%s %s" % (
self.person.name,
", ".join(p.name for p in self.permissions.all()),
)
class Book(models.Model):
name = models.CharField(max_length=100)
authors = models.ManyToManyField(Person)
class Meta:
ordering = ("name",)
def __str__(self):
authors = " and ".join(a.name for a in self.authors.all())
return "%s by %s" % (self.name, authors) if authors else self.name
class PrimaryKeyUUIDModel(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4)
class NaturalKeyManager(models.Manager):
def get_by_natural_key(self, key):
return self.get(key=key)
class NaturalKeyThing(models.Model):
key = models.CharField(max_length=100, unique=True)
other_thing = models.ForeignKey(
"NaturalKeyThing", on_delete=models.CASCADE, null=True
)
other_things = models.ManyToManyField(
"NaturalKeyThing", related_name="thing_m2m_set"
)
objects = NaturalKeyManager()
def natural_key(self):
return (self.key,)
def __str__(self):
return self.key
class CircularA(models.Model):
key = models.CharField(max_length=3, unique=True)
obj = models.ForeignKey("CircularB", models.SET_NULL, null=True)
objects = NaturalKeyManager()
def natural_key(self):
return (self.key,)
class CircularB(models.Model):
key = models.CharField(max_length=3, unique=True)
obj = models.ForeignKey("CircularA", models.SET_NULL, null=True)
objects = NaturalKeyManager()
def natural_key(self):
return (self.key,)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/fixtures/__init__.py | tests/fixtures/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/fixtures/tests.py | tests/fixtures/tests.py | import gzip
import os
import sys
import tempfile
import unittest
import warnings
from io import StringIO
from unittest import mock
from django.apps import apps
from django.contrib.sites.models import Site
from django.core import management
from django.core.files.temp import NamedTemporaryFile
from django.core.management import CommandError
from django.core.management.commands.dumpdata import ProxyModelWarning
from django.core.serializers.base import ProgressBar
from django.db import IntegrityError, connection
from django.test import TestCase, TransactionTestCase, skipUnlessDBFeature
from .models import (
Article,
Category,
CircularA,
CircularB,
NaturalKeyThing,
Person,
PrimaryKeyUUIDModel,
ProxySpy,
Spy,
Tag,
Visa,
)
try:
import bz2 # NOQA
HAS_BZ2 = True
except ImportError:
HAS_BZ2 = False
try:
import lzma # NOQA
HAS_LZMA = True
except ImportError:
HAS_LZMA = False
class TestCaseFixtureLoadingTests(TestCase):
fixtures = ["fixture1.json", "fixture2.json"]
def test_class_fixtures(self):
"Test case has installed 3 fixture objects"
self.assertSequenceEqual(
Article.objects.values_list("headline", flat=True),
[
"Django conquers world!",
"Copyright is fine the way it is",
"Poker has no place on ESPN",
],
)
class SubclassTestCaseFixtureLoadingTests(TestCaseFixtureLoadingTests):
"""
Make sure that subclasses can remove fixtures from parent class (#21089).
"""
fixtures = []
def test_class_fixtures(self):
"There were no fixture objects installed"
self.assertEqual(Article.objects.count(), 0)
class DumpDataAssertMixin:
def _dumpdata_assert(
self,
args,
output,
format="json",
filename=None,
natural_foreign_keys=False,
natural_primary_keys=False,
use_base_manager=False,
exclude_list=[],
primary_keys="",
):
new_io = StringIO()
filename = filename and os.path.join(tempfile.gettempdir(), filename)
management.call_command(
"dumpdata",
*args,
format=format,
stdout=new_io,
stderr=new_io,
output=filename,
use_natural_foreign_keys=natural_foreign_keys,
use_natural_primary_keys=natural_primary_keys,
use_base_manager=use_base_manager,
exclude=exclude_list,
primary_keys=primary_keys,
)
if filename:
file_root, file_ext = os.path.splitext(filename)
compression_formats = {
".bz2": (open, file_root),
".gz": (gzip.open, filename),
".lzma": (open, file_root),
".xz": (open, file_root),
".zip": (open, file_root),
}
if HAS_BZ2:
compression_formats[".bz2"] = (bz2.open, filename)
if HAS_LZMA:
compression_formats[".lzma"] = (lzma.open, filename)
compression_formats[".xz"] = (lzma.open, filename)
try:
open_method, file_path = compression_formats[file_ext]
except KeyError:
open_method, file_path = open, filename
with open_method(file_path, "rt") as f:
command_output = f.read()
os.remove(file_path)
else:
command_output = new_io.getvalue().strip()
if format == "json":
self.assertJSONEqual(command_output, output)
elif format == "xml":
self.assertXMLEqual(command_output, output)
else:
self.assertEqual(command_output, output)
class FixtureLoadingTests(DumpDataAssertMixin, TestCase):
def test_loading_and_dumping(self):
apps.clear_cache()
Site.objects.all().delete()
# Load fixture 1. Single JSON file, with two objects.
management.call_command("loaddata", "fixture1.json", verbosity=0)
self.assertSequenceEqual(
Article.objects.values_list("headline", flat=True),
["Time to reform copyright", "Poker has no place on ESPN"],
)
# Dump the current contents of the database as a JSON fixture
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# Try just dumping the contents of fixtures.Category
self._dumpdata_assert(
["fixtures.Category"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}]',
)
# ...and just fixtures.Article
self._dumpdata_assert(
["fixtures.Article"],
'[{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# ...and both
self._dumpdata_assert(
["fixtures.Category", "fixtures.Article"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# Specify a specific model twice
self._dumpdata_assert(
["fixtures.Article", "fixtures.Article"],
(
'[{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]'
),
)
# Specify a dump that specifies Article both explicitly and implicitly
self._dumpdata_assert(
["fixtures.Article", "fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# Specify a dump that specifies Article both explicitly and implicitly,
# but lists the app first (#22025).
self._dumpdata_assert(
["fixtures", "fixtures.Article"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# Same again, but specify in the reverse order
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
)
# Specify one model from one application, and an entire other
# application.
self._dumpdata_assert(
["fixtures.Category", "sites"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 1, "model": "sites.site", "fields": '
'{"domain": "example.com", "name": "example.com"}}]',
)
# Load fixture 2. JSON file imported by default. Overwrites some
# existing objects.
management.call_command("loaddata", "fixture2.json", verbosity=0)
self.assertSequenceEqual(
Article.objects.values_list("headline", flat=True),
[
"Django conquers world!",
"Copyright is fine the way it is",
"Poker has no place on ESPN",
],
)
# Load fixture 3, XML format.
management.call_command("loaddata", "fixture3.xml", verbosity=0)
self.assertSequenceEqual(
Article.objects.values_list("headline", flat=True),
[
"XML identified as leading cause of cancer",
"Django conquers world!",
"Copyright is fine the way it is",
"Poker on TV is great!",
],
)
# Load fixture 6, JSON file with dynamic ContentType fields. Testing
# ManyToOne.
management.call_command("loaddata", "fixture6.json", verbosity=0)
self.assertQuerySetEqual(
Tag.objects.all(),
[
'<Tag: <Article: Copyright is fine the way it is> tagged "copyright">',
'<Tag: <Article: Copyright is fine the way it is> tagged "law">',
],
transform=repr,
ordered=False,
)
# Load fixture 7, XML file with dynamic ContentType fields. Testing
# ManyToOne.
management.call_command("loaddata", "fixture7.xml", verbosity=0)
self.assertQuerySetEqual(
Tag.objects.all(),
[
'<Tag: <Article: Copyright is fine the way it is> tagged "copyright">',
'<Tag: <Article: Copyright is fine the way it is> tagged "legal">',
'<Tag: <Article: Django conquers world!> tagged "django">',
'<Tag: <Article: Django conquers world!> tagged "world domination">',
],
transform=repr,
ordered=False,
)
# Load fixture 8, JSON file with dynamic Permission fields. Testing
# ManyToMany.
management.call_command("loaddata", "fixture8.json", verbosity=0)
self.assertQuerySetEqual(
Visa.objects.all(),
[
"<Visa: Django Reinhardt Can add user, Can change user, Can delete "
"user>",
"<Visa: Stephane Grappelli Can add user>",
"<Visa: Prince >",
],
transform=repr,
ordered=False,
)
# Load fixture 9, XML file with dynamic Permission fields. Testing
# ManyToMany.
management.call_command("loaddata", "fixture9.xml", verbosity=0)
self.assertQuerySetEqual(
Visa.objects.all(),
[
"<Visa: Django Reinhardt Can add user, Can change user, Can delete "
"user>",
"<Visa: Stephane Grappelli Can add user, Can delete user>",
'<Visa: Artist formerly known as "Prince" Can change user>',
],
transform=repr,
ordered=False,
)
# object list is unaffected
self.assertSequenceEqual(
Article.objects.values_list("headline", flat=True),
[
"XML identified as leading cause of cancer",
"Django conquers world!",
"Copyright is fine the way it is",
"Poker on TV is great!",
],
)
# By default, you get raw keys on dumpdata
self._dumpdata_assert(
["fixtures.book"],
'[{"pk": 1, "model": "fixtures.book", "fields": '
'{"name": "Music for all ages", "authors": [3, 1]}}]',
)
# But you can get natural keys if you ask for them and they are
# available
self._dumpdata_assert(
["fixtures.book"],
'[{"pk": 1, "model": "fixtures.book", "fields": '
'{"name": "Music for all ages", "authors": '
'[["Artist formerly known as \\"Prince\\""], ["Django Reinhardt"]]}}]',
natural_foreign_keys=True,
)
# You can also omit the primary keys for models that we can get later
# with natural keys.
self._dumpdata_assert(
["fixtures.person"],
'[{"fields": {"name": "Django Reinhardt"}, "model": "fixtures.person"}, '
'{"fields": {"name": "Stephane Grappelli"}, "model": "fixtures.person"}, '
'{"fields": {"name": "Artist formerly known as \\"Prince\\""}, '
'"model": "fixtures.person"}]',
natural_primary_keys=True,
)
# Dump the current contents of the database as a JSON fixture
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker on TV is great!", '
'"pub_date": "2006-06-16T11:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Copyright is fine the way it is", '
'"pub_date": "2006-06-16T14:00:00"}}, '
'{"pk": 4, "model": "fixtures.article", "fields": '
'{"headline": "Django conquers world!", '
'"pub_date": "2006-06-16T15:00:00"}}, '
'{"pk": 5, "model": "fixtures.article", "fields": '
'{"headline": "XML identified as leading cause of cancer", '
'"pub_date": "2006-06-16T16:00:00"}}, '
'{"pk": 1, "model": "fixtures.tag", "fields": '
'{"tagged_type": ["fixtures", "article"], "name": "copyright", '
'"tagged_id": 3}}, '
'{"pk": 2, "model": "fixtures.tag", "fields": '
'{"tagged_type": ["fixtures", "article"], "name": "legal", '
'"tagged_id": 3}}, '
'{"pk": 3, "model": "fixtures.tag", "fields": '
'{"tagged_type": ["fixtures", "article"], "name": "django", '
'"tagged_id": 4}}, '
'{"pk": 4, "model": "fixtures.tag", "fields": '
'{"tagged_type": ["fixtures", "article"], "name": "world domination", '
'"tagged_id": 4}}, '
'{"pk": 1, "model": "fixtures.person", '
'"fields": {"name": "Django Reinhardt"}}, '
'{"pk": 2, "model": "fixtures.person", '
'"fields": {"name": "Stephane Grappelli"}}, '
'{"pk": 3, "model": "fixtures.person", '
'"fields": {"name": "Artist formerly known as \\"Prince\\""}}, '
'{"pk": 1, "model": "fixtures.visa", '
'"fields": {"person": ["Django Reinhardt"], "permissions": '
'[["add_user", "auth", "user"], ["change_user", "auth", "user"], '
'["delete_user", "auth", "user"]]}}, '
'{"pk": 2, "model": "fixtures.visa", "fields": '
'{"person": ["Stephane Grappelli"], "permissions": '
'[["add_user", "auth", "user"], ["delete_user", "auth", "user"]]}}, '
'{"pk": 3, "model": "fixtures.visa", "fields": '
'{"person": ["Artist formerly known as \\"Prince\\""], "permissions": '
'[["change_user", "auth", "user"]]}}, '
'{"pk": 1, "model": "fixtures.book", "fields": '
'{"name": "Music for all ages", "authors": '
'[["Artist formerly known as \\"Prince\\""], ["Django Reinhardt"]]}}]',
natural_foreign_keys=True,
)
# Dump the current contents of the database as an XML fixture
self._dumpdata_assert(
["fixtures"],
'<?xml version="1.0" encoding="utf-8"?><django-objects version="1.0">'
'<object pk="1" model="fixtures.category">'
'<field type="CharField" name="title">News Stories</field>'
'<field type="TextField" name="description">Latest news stories</field>'
"</object>"
'<object pk="2" model="fixtures.article">'
'<field type="CharField" name="headline">Poker on TV is great!</field>'
'<field type="DateTimeField" name="pub_date">2006-06-16T11:00:00</field>'
"</object>"
'<object pk="3" model="fixtures.article">'
'<field type="CharField" name="headline">Copyright is fine the way it is'
"</field>"
'<field type="DateTimeField" name="pub_date">2006-06-16T14:00:00</field>'
"</object>"
'<object pk="4" model="fixtures.article">'
'<field type="CharField" name="headline">Django conquers world!</field>'
'<field type="DateTimeField" name="pub_date">2006-06-16T15:00:00</field>'
"</object>"
'<object pk="5" model="fixtures.article">'
'<field type="CharField" name="headline">'
"XML identified as leading cause of cancer</field>"
'<field type="DateTimeField" name="pub_date">2006-06-16T16:00:00</field>'
"</object>"
'<object pk="1" model="fixtures.tag">'
'<field type="CharField" name="name">copyright</field>'
'<field to="contenttypes.contenttype" name="tagged_type" '
'rel="ManyToOneRel"><natural>fixtures</natural><natural>article</natural>'
"</field>"
'<field type="PositiveIntegerField" name="tagged_id">3</field>'
"</object>"
'<object pk="2" model="fixtures.tag">'
'<field type="CharField" name="name">legal</field>'
'<field to="contenttypes.contenttype" name="tagged_type" '
'rel="ManyToOneRel"><natural>fixtures</natural><natural>article</natural>'
"</field>"
'<field type="PositiveIntegerField" name="tagged_id">3</field></object>'
'<object pk="3" model="fixtures.tag">'
'<field type="CharField" name="name">django</field>'
'<field to="contenttypes.contenttype" name="tagged_type" '
'rel="ManyToOneRel"><natural>fixtures</natural><natural>article</natural>'
"</field>"
'<field type="PositiveIntegerField" name="tagged_id">4</field>'
"</object>"
'<object pk="4" model="fixtures.tag">'
'<field type="CharField" name="name">world domination</field>'
'<field to="contenttypes.contenttype" name="tagged_type" '
'rel="ManyToOneRel"><natural>fixtures</natural><natural>article</natural>'
"</field>"
'<field type="PositiveIntegerField" name="tagged_id">4</field>'
"</object>"
'<object pk="1" model="fixtures.person">'
'<field type="CharField" name="name">Django Reinhardt</field>'
"</object>"
'<object pk="2" model="fixtures.person">'
'<field type="CharField" name="name">Stephane Grappelli</field>'
"</object>"
'<object pk="3" model="fixtures.person">'
'<field type="CharField" name="name">Artist formerly known as "Prince"'
"</field>"
"</object>"
'<object pk="1" model="fixtures.visa">'
'<field to="fixtures.person" name="person" rel="ManyToOneRel">'
"<natural>Django Reinhardt</natural></field>"
'<field to="auth.permission" name="permissions" rel="ManyToManyRel">'
"<object><natural>add_user</natural><natural>auth</natural>"
"<natural>user</natural></object><object><natural>change_user</natural>"
"<natural>auth</natural><natural>user</natural></object>"
"<object><natural>delete_user</natural><natural>auth</natural>"
"<natural>user</natural></object></field>"
"</object>"
'<object pk="2" model="fixtures.visa">'
'<field to="fixtures.person" name="person" rel="ManyToOneRel">'
"<natural>Stephane Grappelli</natural></field>"
'<field to="auth.permission" name="permissions" rel="ManyToManyRel">'
"<object><natural>add_user</natural><natural>auth</natural>"
"<natural>user</natural></object>"
"<object><natural>delete_user</natural><natural>auth</natural>"
"<natural>user</natural></object></field>"
"</object>"
'<object pk="3" model="fixtures.visa">'
'<field to="fixtures.person" name="person" rel="ManyToOneRel">'
'<natural>Artist formerly known as "Prince"</natural></field>'
'<field to="auth.permission" name="permissions" rel="ManyToManyRel">'
"<object><natural>change_user</natural><natural>auth</natural>"
"<natural>user</natural></object></field>"
"</object>"
'<object pk="1" model="fixtures.book">'
'<field type="CharField" name="name">Music for all ages</field>'
'<field to="fixtures.person" name="authors" rel="ManyToManyRel">'
'<object><natural>Artist formerly known as "Prince"</natural></object>'
"<object><natural>Django Reinhardt</natural></object></field>"
"</object></django-objects>",
format="xml",
natural_foreign_keys=True,
)
def test_deeply_nested_elements(self):
"""Text inside deeply-nested tags is skipped."""
management.call_command(
"loaddata", "invalid_deeply_nested_elements.xml", verbosity=0
)
person = Person.objects.get(pk=1)
self.assertEqual(person.name, "Django") # not "Django pony"
def test_dumpdata_with_excludes(self):
# Load fixture1 which has a site, two articles, and a category
Site.objects.all().delete()
management.call_command("loaddata", "fixture1.json", verbosity=0)
# Excluding fixtures app should only leave sites
self._dumpdata_assert(
["sites", "fixtures"],
'[{"pk": 1, "model": "sites.site", "fields": '
'{"domain": "example.com", "name": "example.com"}}]',
exclude_list=["fixtures"],
)
# Excluding fixtures.Article/Book should leave fixtures.Category
self._dumpdata_assert(
["sites", "fixtures"],
'[{"pk": 1, "model": "sites.site", '
'"fields": {"domain": "example.com", "name": "example.com"}}, '
'{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}]',
exclude_list=["fixtures.Article", "fixtures.Book"],
)
# Excluding fixtures and fixtures.Article/Book should be a no-op
self._dumpdata_assert(
["sites", "fixtures"],
'[{"pk": 1, "model": "sites.site", '
'"fields": {"domain": "example.com", "name": "example.com"}}, '
'{"pk": 1, "model": "fixtures.category", '
'"fields": {"description": "Latest news stories", '
'"title": "News Stories"}}]',
exclude_list=["fixtures.Article", "fixtures.Book"],
)
# Excluding sites and fixtures.Article/Book should only leave
# fixtures.Category
self._dumpdata_assert(
["sites", "fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}]',
exclude_list=["fixtures.Article", "fixtures.Book", "sites"],
)
# Excluding a bogus app should throw an error
with self.assertRaisesMessage(
management.CommandError, "No installed app with label 'foo_app'."
):
self._dumpdata_assert(["fixtures", "sites"], "", exclude_list=["foo_app"])
# Excluding a bogus model should throw an error
with self.assertRaisesMessage(
management.CommandError, "Unknown model: fixtures.FooModel"
):
self._dumpdata_assert(
["fixtures", "sites"], "", exclude_list=["fixtures.FooModel"]
)
@unittest.skipIf(
sys.platform == "win32", "Windows doesn't support '?' in filenames."
)
def test_load_fixture_with_special_characters(self):
management.call_command("loaddata", "fixture_with[special]chars", verbosity=0)
self.assertEqual(
Article.objects.get().headline,
"How To Deal With Special Characters",
)
def test_dumpdata_with_filtering_manager(self):
spy1 = Spy.objects.create(name="Paul")
spy2 = Spy.objects.create(name="Alex", cover_blown=True)
self.assertSequenceEqual(Spy.objects.all(), [spy1])
# Use the default manager
self._dumpdata_assert(
["fixtures.Spy"],
'[{"pk": %d, "model": "fixtures.spy", "fields": {"cover_blown": false}}]'
% spy1.pk,
)
# Dump using Django's base manager. Should return all objects,
# even those normally filtered by the manager
self._dumpdata_assert(
["fixtures.Spy"],
'[{"pk": %d, "model": "fixtures.spy", "fields": {"cover_blown": true}}, '
'{"pk": %d, "model": "fixtures.spy", "fields": {"cover_blown": false}}]'
% (spy2.pk, spy1.pk),
use_base_manager=True,
)
def test_dumpdata_with_pks(self):
management.call_command("loaddata", "fixture1.json", verbosity=0)
management.call_command("loaddata", "fixture2.json", verbosity=0)
self._dumpdata_assert(
["fixtures.Article"],
'[{"pk": 2, "model": "fixtures.article", '
'"fields": {"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Copyright is fine the way it is", '
'"pub_date": "2006-06-16T14:00:00"}}]',
primary_keys="2,3",
)
self._dumpdata_assert(
["fixtures.Article"],
'[{"pk": 2, "model": "fixtures.article", '
'"fields": {"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}]',
primary_keys="2",
)
with self.assertRaisesMessage(
management.CommandError, "You can only use --pks option with one model"
):
self._dumpdata_assert(
["fixtures"],
'[{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Copyright is fine the way it is", '
'"pub_date": "2006-06-16T14:00:00"}}]',
primary_keys="2,3",
)
with self.assertRaisesMessage(
management.CommandError, "You can only use --pks option with one model"
):
self._dumpdata_assert(
"",
'[{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Copyright is fine the way it is", '
'"pub_date": "2006-06-16T14:00:00"}}]',
primary_keys="2,3",
)
with self.assertRaisesMessage(
management.CommandError, "You can only use --pks option with one model"
):
self._dumpdata_assert(
["fixtures.Article", "fixtures.category"],
'[{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Copyright is fine the way it is", '
'"pub_date": "2006-06-16T14:00:00"}}]',
primary_keys="2,3",
)
def test_dumpdata_with_uuid_pks(self):
m1 = PrimaryKeyUUIDModel.objects.create()
m2 = PrimaryKeyUUIDModel.objects.create()
output = StringIO()
management.call_command(
"dumpdata",
"fixtures.PrimaryKeyUUIDModel",
"--pks",
", ".join([str(m1.id), str(m2.id)]),
stdout=output,
)
result = output.getvalue()
self.assertIn('"pk": "%s"' % m1.id, result)
self.assertIn('"pk": "%s"' % m2.id, result)
def test_dumpdata_with_file_output(self):
management.call_command("loaddata", "fixture1.json", verbosity=0)
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
filename="dumpdata.json",
)
def test_dumpdata_with_file_gzip_output(self):
management.call_command("loaddata", "fixture1.json", verbosity=0)
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
filename="dumpdata.json.gz",
)
@unittest.skipUnless(HAS_BZ2, "No bz2 library detected.")
def test_dumpdata_with_file_bz2_output(self):
management.call_command("loaddata", "fixture1.json", verbosity=0)
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
'"pub_date": "2006-06-16T12:00:00"}}, '
'{"pk": 3, "model": "fixtures.article", "fields": '
'{"headline": "Time to reform copyright", '
'"pub_date": "2006-06-16T13:00:00"}}]',
filename="dumpdata.json.bz2",
)
@unittest.skipUnless(HAS_LZMA, "No lzma library detected.")
def test_dumpdata_with_file_lzma_output(self):
management.call_command("loaddata", "fixture1.json", verbosity=0)
self._dumpdata_assert(
["fixtures"],
'[{"pk": 1, "model": "fixtures.category", "fields": '
'{"description": "Latest news stories", "title": "News Stories"}}, '
'{"pk": 2, "model": "fixtures.article", "fields": '
'{"headline": "Poker has no place on ESPN", '
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_session.py | tests/messages_tests/test_session.py | from django.contrib.messages import Message, constants
from django.contrib.messages.storage.session import SessionStorage
from django.core.exceptions import ImproperlyConfigured
from django.http import HttpRequest
from django.test import TestCase
from django.utils.safestring import SafeData, mark_safe
from .base import BaseTests
def set_session_data(storage, messages):
"""
Sets the messages into the backend request's session and remove the
backend's loaded data cache.
"""
storage.request.session[storage.session_key] = storage.serialize_messages(messages)
if hasattr(storage, "_loaded_data"):
del storage._loaded_data
def stored_session_messages_count(storage):
data = storage.deserialize_messages(
storage.request.session.get(storage.session_key, [])
)
return len(data)
class SessionTests(BaseTests, TestCase):
storage_class = SessionStorage
def get_request(self):
self.session = {}
request = super().get_request()
request.session = self.session
return request
def stored_messages_count(self, storage, response):
return stored_session_messages_count(storage)
def test_no_session(self):
msg = (
"The session-based temporary message storage requires session "
"middleware to be installed, and come before the message "
"middleware in the MIDDLEWARE list."
)
with self.assertRaisesMessage(ImproperlyConfigured, msg):
self.storage_class(HttpRequest())
def test_get(self):
storage = self.storage_class(self.get_request())
example_messages = ["test", "me"]
set_session_data(storage, example_messages)
self.assertEqual(list(storage), example_messages)
def test_safedata(self):
"""
A message containing SafeData keeps its safe status when retrieved from
the message storage.
"""
storage = self.get_storage()
message = Message(constants.DEBUG, mark_safe("<b>Hello Django!</b>"))
set_session_data(storage, [message])
self.assertIsInstance(list(storage)[0].message, SafeData)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/models.py | tests/messages_tests/models.py | from django.db import models
class SomeObject(models.Model):
name = models.CharField(max_length=255)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_cookie.py | tests/messages_tests/test_cookie.py | import json
import random
from unittest import TestCase
from django.conf import settings
from django.contrib.messages import Message, constants
from django.contrib.messages.storage.cookie import (
CookieStorage,
MessageDecoder,
MessageEncoder,
bisect_keep_left,
bisect_keep_right,
)
from django.test import SimpleTestCase, override_settings
from django.utils.crypto import get_random_string
from django.utils.safestring import SafeData, mark_safe
from .base import BaseTests
def set_cookie_data(storage, messages, invalid=False, encode_empty=False):
"""
Set ``request.COOKIES`` with the encoded data and remove the storage
backend's loaded data cache.
"""
encoded_data = storage._encode(messages, encode_empty=encode_empty)
if invalid:
# Truncate the first character so that the hash is invalid.
encoded_data = encoded_data[1:]
storage.request.COOKIES = {CookieStorage.cookie_name: encoded_data}
if hasattr(storage, "_loaded_data"):
del storage._loaded_data
def stored_cookie_messages_count(storage, response):
"""
Return an integer containing the number of messages stored.
"""
# Get a list of cookies, excluding ones with a max-age of 0 (because
# they have been marked for deletion).
cookie = response.cookies.get(storage.cookie_name)
if not cookie or cookie["max-age"] == 0:
return 0
data = storage._decode(cookie.value)
if not data:
return 0
if data[-1] == CookieStorage.not_finished:
data.pop()
return len(data)
@override_settings(
SESSION_COOKIE_DOMAIN=".example.com",
SESSION_COOKIE_SECURE=True,
SESSION_COOKIE_HTTPONLY=True,
)
class CookieTests(BaseTests, SimpleTestCase):
storage_class = CookieStorage
def stored_messages_count(self, storage, response):
return stored_cookie_messages_count(storage, response)
def encode_decode(self, *args, **kwargs):
storage = self.get_storage()
message = [Message(constants.DEBUG, *args, **kwargs)]
encoded = storage._encode(message)
return storage._decode(encoded)[0]
def test_get(self):
storage = self.storage_class(self.get_request())
# Set initial data.
example_messages = ["test", "me"]
set_cookie_data(storage, example_messages)
# The message contains what's expected.
self.assertEqual(list(storage), example_messages)
@override_settings(SESSION_COOKIE_SAMESITE="Strict")
def test_cookie_settings(self):
"""
CookieStorage honors SESSION_COOKIE_DOMAIN, SESSION_COOKIE_SECURE, and
SESSION_COOKIE_HTTPONLY (#15618, #20972).
"""
# Test before the messages have been consumed
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, "test")
storage.update(response)
messages = storage._decode(response.cookies["messages"].value)
self.assertEqual(len(messages), 1)
self.assertEqual(messages[0].message, "test")
self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
self.assertEqual(response.cookies["messages"]["expires"], "")
self.assertIs(response.cookies["messages"]["secure"], True)
self.assertIs(response.cookies["messages"]["httponly"], True)
self.assertEqual(response.cookies["messages"]["samesite"], "Strict")
# Deletion of the cookie (storing with an empty value) after the
# messages have been consumed.
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, "test")
for m in storage:
pass # Iterate through the storage to simulate consumption of messages.
storage.update(response)
self.assertEqual(response.cookies["messages"].value, "")
self.assertEqual(response.cookies["messages"]["domain"], ".example.com")
self.assertEqual(
response.cookies["messages"]["expires"], "Thu, 01 Jan 1970 00:00:00 GMT"
)
self.assertEqual(
response.cookies["messages"]["samesite"],
settings.SESSION_COOKIE_SAMESITE,
)
def test_get_bad_cookie(self):
request = self.get_request()
storage = self.storage_class(request)
# Set initial (invalid) data.
example_messages = ["test", "me"]
set_cookie_data(storage, example_messages, invalid=True)
# The message actually contains what we expect.
self.assertEqual(list(storage), [])
def test_max_cookie_length(self):
"""
If the data exceeds what is allowed in a cookie, older messages are
removed before saving (and returned by the ``update`` method).
"""
storage = self.get_storage()
response = self.get_response()
# When storing as a cookie, the cookie has constant overhead of approx
# 54 chars, and each message has a constant overhead of about 37 chars
# and a variable overhead of zero in the best case. We aim for a
# message size which will fit 4 messages into the cookie, but not 5.
# See also FallbackTest.test_session_fallback
msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37)
first_msg = None
# Generate the same (tested) content every time that does not get run
# through zlib compression.
random.seed(42)
for i in range(5):
msg = get_random_string(msg_size)
storage.add(constants.INFO, msg)
if i == 0:
first_msg = msg
unstored_messages = storage.update(response)
cookie_storing = self.stored_messages_count(storage, response)
self.assertEqual(cookie_storing, 4)
self.assertEqual(len(unstored_messages), 1)
self.assertEqual(unstored_messages[0].message, first_msg)
def test_message_rfc6265(self):
non_compliant_chars = ["\\", ",", ";", '"']
messages = ["\\te,st", ';m"e', "\u2019", '123"NOTRECEIVED"']
storage = self.get_storage()
encoded = storage._encode(messages)
for illegal in non_compliant_chars:
self.assertEqual(encoded.find(illegal), -1)
def test_json_encoder_decoder(self):
"""
A complex nested data structure containing Message
instances is properly encoded/decoded by the custom JSON
encoder/decoder classes.
"""
messages = [
{
"message": Message(constants.INFO, "Test message"),
"message_list": [
Message(constants.INFO, "message %s") for x in range(5)
]
+ [{"another-message": Message(constants.ERROR, "error")}],
},
Message(constants.INFO, "message %s"),
]
encoder = MessageEncoder()
value = encoder.encode(messages)
decoded_messages = json.loads(value, cls=MessageDecoder)
self.assertEqual(messages, decoded_messages)
def test_safedata(self):
"""
A message containing SafeData is keeping its safe status when
retrieved from the message storage.
"""
self.assertIsInstance(
self.encode_decode(mark_safe("<b>Hello Django!</b>")).message,
SafeData,
)
self.assertNotIsInstance(
self.encode_decode("<b>Hello Django!</b>").message,
SafeData,
)
def test_extra_tags(self):
"""
A message's extra_tags attribute is correctly preserved when retrieved
from the message storage.
"""
for extra_tags in ["", None, "some tags"]:
with self.subTest(extra_tags=extra_tags):
self.assertEqual(
self.encode_decode("message", extra_tags=extra_tags).extra_tags,
extra_tags,
)
class BisectTests(TestCase):
def test_bisect_keep_left(self):
self.assertEqual(bisect_keep_left([1, 1, 1], fn=lambda arr: sum(arr) != 2), 2)
self.assertEqual(bisect_keep_left([1, 1, 1], fn=lambda arr: sum(arr) != 0), 0)
self.assertEqual(bisect_keep_left([], fn=lambda arr: sum(arr) != 0), 0)
def test_bisect_keep_right(self):
self.assertEqual(bisect_keep_right([1, 1, 1], fn=lambda arr: sum(arr) != 2), 1)
self.assertEqual(
bisect_keep_right([1, 1, 1, 1], fn=lambda arr: sum(arr) != 2), 2
)
self.assertEqual(
bisect_keep_right([1, 1, 1, 1, 1], fn=lambda arr: sum(arr) != 1), 4
)
self.assertEqual(bisect_keep_right([], fn=lambda arr: sum(arr) != 0), 0)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/utils.py | tests/messages_tests/utils.py | from django.contrib.messages import Message
class DummyStorage:
"""Dummy message-store to test the API methods."""
def __init__(self):
self.store = []
def add(self, level, message, extra_tags=""):
self.store.append(Message(level, message, extra_tags))
def __iter__(self):
return iter(self.store)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_middleware.py | tests/messages_tests/test_middleware.py | import unittest
from django.contrib.messages.middleware import MessageMiddleware
from django.http import HttpRequest, HttpResponse
class MiddlewareTests(unittest.TestCase):
def test_response_without_messages(self):
"""
MessageMiddleware is tolerant of messages not existing on request.
"""
request = HttpRequest()
response = HttpResponse()
MessageMiddleware(lambda req: HttpResponse()).process_response(
request, response
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_api.py | tests/messages_tests/test_api.py | from django.contrib import messages
from django.test import RequestFactory, SimpleTestCase
from .utils import DummyStorage
class ApiTests(SimpleTestCase):
rf = RequestFactory()
def setUp(self):
self.request = self.rf.request()
self.storage = DummyStorage()
def test_ok(self):
msg = "some message"
self.request._messages = self.storage
messages.add_message(self.request, messages.DEBUG, msg)
[message] = self.storage.store
self.assertEqual(msg, message.message)
def test_request_is_none(self):
msg = "add_message() argument must be an HttpRequest object, not 'NoneType'."
self.request._messages = self.storage
with self.assertRaisesMessage(TypeError, msg):
messages.add_message(None, messages.DEBUG, "some message")
self.assertEqual(self.storage.store, [])
def test_middleware_missing(self):
msg = (
"You cannot add messages without installing "
"django.contrib.messages.middleware.MessageMiddleware"
)
with self.assertRaisesMessage(messages.MessageFailure, msg):
messages.add_message(self.request, messages.DEBUG, "some message")
self.assertEqual(self.storage.store, [])
def test_middleware_missing_silently(self):
messages.add_message(
self.request, messages.DEBUG, "some message", fail_silently=True
)
self.assertEqual(self.storage.store, [])
class CustomRequest:
def __init__(self, request):
self._request = request
def __getattribute__(self, attr):
try:
return super().__getattribute__(attr)
except AttributeError:
return getattr(self._request, attr)
class CustomRequestApiTests(ApiTests):
"""
add_message() should use ducktyping to allow request wrappers such as the
one in Django REST framework.
"""
def setUp(self):
super().setUp()
self.request = CustomRequest(self.request)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/__init__.py | tests/messages_tests/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_mixins.py | tests/messages_tests/test_mixins.py | from django.core.signing import b64_decode
from django.test import TestCase, override_settings
from django.urls import reverse
from .models import SomeObject
from .urls import ContactFormViewWithMsg, DeleteFormViewWithMsg
@override_settings(ROOT_URLCONF="messages_tests.urls")
class SuccessMessageMixinTests(TestCase):
def test_set_messages_success(self):
author = {"name": "John Doe", "slug": "success-msg"}
add_url = reverse("add_success_msg")
req = self.client.post(add_url, author)
# Uncompressed message is stored in the cookie.
value = b64_decode(
req.cookies["messages"].value.split(":")[0].encode(),
).decode()
self.assertIn(ContactFormViewWithMsg.success_message % author, value)
def test_set_messages_success_on_delete(self):
object_to_delete = SomeObject.objects.create(name="MyObject")
delete_url = reverse("success_msg_on_delete", args=[object_to_delete.pk])
response = self.client.post(delete_url, follow=True)
self.assertContains(response, DeleteFormViewWithMsg.success_message)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/tests.py | tests/messages_tests/tests.py | import importlib
import sys
import traceback
import unittest
from unittest import mock
from django.conf import settings
from django.contrib.messages import Message, add_message, constants
from django.contrib.messages.storage import base
from django.contrib.messages.test import MessagesTestMixin
from django.test import RequestFactory, SimpleTestCase, override_settings
from .utils import DummyStorage
class MessageTests(SimpleTestCase):
def test_eq(self):
msg_1 = Message(constants.INFO, "Test message 1")
msg_2 = Message(constants.INFO, "Test message 2")
msg_3 = Message(constants.WARNING, "Test message 1")
self.assertEqual(msg_1, msg_1)
self.assertEqual(msg_1, mock.ANY)
self.assertNotEqual(msg_1, msg_2)
self.assertNotEqual(msg_1, msg_3)
self.assertNotEqual(msg_2, msg_3)
@override_settings(
MESSAGE_TAGS={
constants.WARNING: "caution",
constants.ERROR: "",
12: "custom",
}
)
def test_repr(self):
tests = [
(constants.INFO, "thing", "", "Message(level=20, message='thing')"),
(
constants.WARNING,
"careful",
"tag1 tag2",
"Message(level=30, message='careful', extra_tags='tag1 tag2')",
),
(
constants.ERROR,
"oops",
"tag",
"Message(level=40, message='oops', extra_tags='tag')",
),
(12, "custom", "", "Message(level=12, message='custom')"),
]
for level, message, extra_tags, expected in tests:
with self.subTest(level=level, message=message):
msg = Message(level, message, extra_tags=extra_tags)
self.assertEqual(repr(msg), expected)
class TestLevelTags(SimpleTestCase):
message_tags = {
constants.INFO: "info",
constants.DEBUG: "",
constants.WARNING: "",
constants.ERROR: "bad",
constants.SUCCESS: "",
12: "custom",
}
@override_settings(MESSAGE_TAGS=message_tags)
def test_override_settings_level_tags(self):
self.assertEqual(base.LEVEL_TAGS, self.message_tags)
def test_lazy(self):
storage_base_import_path = "django.contrib.messages.storage.base"
in_use_base = sys.modules.pop(storage_base_import_path)
self.addCleanup(sys.modules.__setitem__, storage_base_import_path, in_use_base)
# Don't use @override_settings to avoid calling the setting_changed
# signal, but ensure that base.LEVEL_TAGS hasn't been read yet (this
# means that we need to ensure the `base` module is freshly imported).
base = importlib.import_module(storage_base_import_path)
old_message_tags = getattr(settings, "MESSAGE_TAGS", None)
settings.MESSAGE_TAGS = {constants.ERROR: "bad"}
try:
self.assertEqual(base.LEVEL_TAGS[constants.ERROR], "bad")
finally:
if old_message_tags is None:
del settings.MESSAGE_TAGS
else:
settings.MESSAGE_TAGS = old_message_tags
@override_settings(MESSAGE_TAGS=message_tags)
def test_override_settings_lazy(self):
# The update_level_tags handler has been called at least once before
# running this code when using @override_settings.
settings.MESSAGE_TAGS = {constants.ERROR: "very-bad"}
self.assertEqual(base.LEVEL_TAGS[constants.ERROR], "very-bad")
class FakeResponse:
def __init__(self):
request = RequestFactory().get("/")
request._messages = DummyStorage()
self.wsgi_request = request
class AssertMessagesTest(MessagesTestMixin, SimpleTestCase):
def test_assertion(self):
response = FakeResponse()
add_message(response.wsgi_request, constants.DEBUG, "DEBUG message.")
add_message(response.wsgi_request, constants.INFO, "INFO message.")
add_message(response.wsgi_request, constants.SUCCESS, "SUCCESS message.")
add_message(response.wsgi_request, constants.WARNING, "WARNING message.")
add_message(response.wsgi_request, constants.ERROR, "ERROR message.")
self.assertMessages(
response,
[
Message(constants.DEBUG, "DEBUG message."),
Message(constants.INFO, "INFO message."),
Message(constants.SUCCESS, "SUCCESS message."),
Message(constants.WARNING, "WARNING message."),
Message(constants.ERROR, "ERROR message."),
],
)
def test_with_tags(self):
response = FakeResponse()
add_message(
response.wsgi_request,
constants.INFO,
"INFO message.",
extra_tags="extra-info",
)
add_message(
response.wsgi_request,
constants.SUCCESS,
"SUCCESS message.",
extra_tags="extra-success",
)
add_message(
response.wsgi_request,
constants.WARNING,
"WARNING message.",
extra_tags="extra-warning",
)
add_message(
response.wsgi_request,
constants.ERROR,
"ERROR message.",
extra_tags="extra-error",
)
self.assertMessages(
response,
[
Message(constants.INFO, "INFO message.", "extra-info"),
Message(constants.SUCCESS, "SUCCESS message.", "extra-success"),
Message(constants.WARNING, "WARNING message.", "extra-warning"),
Message(constants.ERROR, "ERROR message.", "extra-error"),
],
)
@override_settings(MESSAGE_TAGS={42: "CUSTOM"})
def test_custom_levelname(self):
response = FakeResponse()
add_message(response.wsgi_request, 42, "CUSTOM message.")
self.assertMessages(response, [Message(42, "CUSTOM message.")])
def test_ordered(self):
response = FakeResponse()
add_message(response.wsgi_request, constants.INFO, "First message.")
add_message(response.wsgi_request, constants.WARNING, "Second message.")
expected_messages = [
Message(constants.WARNING, "Second message."),
Message(constants.INFO, "First message."),
]
self.assertMessages(response, expected_messages, ordered=False)
with self.assertRaisesMessage(AssertionError, "Lists differ: "):
self.assertMessages(response, expected_messages)
def test_mismatching_length(self):
response = FakeResponse()
add_message(response.wsgi_request, constants.INFO, "INFO message.")
msg = (
"Lists differ: [Message(level=20, message='INFO message.')] != []\n\n"
"First list contains 1 additional elements.\n"
"First extra element 0:\n"
"Message(level=20, message='INFO message.')\n\n"
"- [Message(level=20, message='INFO message.')]\n"
"+ []"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertMessages(response, [])
def test_method_frames_ignored_by_unittest(self):
response = FakeResponse()
try:
self.assertMessages(response, [object()])
except AssertionError:
exc_type, exc, tb = sys.exc_info()
result = unittest.TestResult()
result.addFailure(self, (exc_type, exc, tb))
stack = traceback.extract_tb(exc.__traceback__)
self.assertEqual(len(stack), 1)
# Top element in the stack is this method, not assertMessages.
self.assertEqual(stack[-1].name, "test_method_frames_ignored_by_unittest")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/test_fallback.py | tests/messages_tests/test_fallback.py | import random
from django.contrib.messages import constants
from django.contrib.messages.storage.fallback import CookieStorage, FallbackStorage
from django.test import SimpleTestCase
from django.utils.crypto import get_random_string
from .base import BaseTests
from .test_cookie import set_cookie_data, stored_cookie_messages_count
from .test_session import set_session_data, stored_session_messages_count
class FallbackTests(BaseTests, SimpleTestCase):
storage_class = FallbackStorage
def get_request(self):
self.session = {}
request = super().get_request()
request.session = self.session
return request
def get_cookie_storage(self, storage):
return storage.storages[-2]
def get_session_storage(self, storage):
return storage.storages[-1]
def stored_cookie_messages_count(self, storage, response):
return stored_cookie_messages_count(self.get_cookie_storage(storage), response)
def stored_session_messages_count(self, storage, response):
return stored_session_messages_count(self.get_session_storage(storage))
def stored_messages_count(self, storage, response):
"""
Return the storage totals from both cookie and session backends.
"""
return self.stored_cookie_messages_count(
storage, response
) + self.stored_session_messages_count(storage, response)
def test_get(self):
request = self.get_request()
storage = self.storage_class(request)
cookie_storage = self.get_cookie_storage(storage)
# Set initial cookie data.
example_messages = [str(i) for i in range(5)]
set_cookie_data(cookie_storage, example_messages)
# Overwrite the _get method of the fallback storage to prove it is not
# used (it would cause a TypeError: 'NoneType' object is not callable).
self.get_session_storage(storage)._get = None
self.assertEqual(list(storage), example_messages)
def test_get_empty(self):
request = self.get_request()
storage = self.storage_class(request)
# Overwrite the _get method of the fallback storage to prove it is not
# used (it would cause a TypeError: 'NoneType' object is not callable).
self.get_session_storage(storage)._get = None
self.assertEqual(list(storage), [])
def test_get_fallback(self):
request = self.get_request()
storage = self.storage_class(request)
cookie_storage = self.get_cookie_storage(storage)
session_storage = self.get_session_storage(storage)
# Set initial cookie and session data.
example_messages = [str(i) for i in range(5)]
set_cookie_data(
cookie_storage, example_messages[:4] + [CookieStorage.not_finished]
)
set_session_data(session_storage, example_messages[4:])
self.assertEqual(list(storage), example_messages)
def test_get_fallback_only(self):
request = self.get_request()
storage = self.storage_class(request)
cookie_storage = self.get_cookie_storage(storage)
session_storage = self.get_session_storage(storage)
# Set initial cookie and session data.
example_messages = [str(i) for i in range(5)]
set_cookie_data(cookie_storage, [CookieStorage.not_finished], encode_empty=True)
set_session_data(session_storage, example_messages)
self.assertEqual(list(storage), example_messages)
def test_flush_used_backends(self):
request = self.get_request()
storage = self.storage_class(request)
cookie_storage = self.get_cookie_storage(storage)
session_storage = self.get_session_storage(storage)
# Set initial cookie and session data.
set_cookie_data(cookie_storage, ["cookie", CookieStorage.not_finished])
set_session_data(session_storage, ["session"])
# When updating, previously used but no longer needed backends are
# flushed.
response = self.get_response()
list(storage)
storage.update(response)
session_storing = self.stored_session_messages_count(storage, response)
self.assertEqual(session_storing, 0)
def test_no_fallback(self):
"""
(1) A short number of messages whose data size doesn't exceed what is
allowed in a cookie will all be stored in the CookieBackend.
(2) If the CookieBackend can store all messages, the SessionBackend
won't be written to at all.
"""
storage = self.get_storage()
response = self.get_response()
# Overwrite the _store method of the fallback storage to prove it isn't
# used (it would cause a TypeError: 'NoneType' object is not callable).
self.get_session_storage(storage)._store = None
for i in range(5):
storage.add(constants.INFO, str(i) * 100)
storage.update(response)
cookie_storing = self.stored_cookie_messages_count(storage, response)
self.assertEqual(cookie_storing, 5)
session_storing = self.stored_session_messages_count(storage, response)
self.assertEqual(session_storing, 0)
def test_session_fallback(self):
"""
If the data exceeds what is allowed in a cookie, messages which did
not fit are stored in the SessionBackend.
"""
storage = self.get_storage()
response = self.get_response()
# see comment in CookieTests.test_cookie_max_length()
msg_size = int((CookieStorage.max_cookie_size - 54) / 4.5 - 37)
# Generate the same (tested) content every time that does not get run
# through zlib compression.
random.seed(42)
for i in range(5):
storage.add(constants.INFO, get_random_string(msg_size))
storage.update(response)
cookie_storing = self.stored_cookie_messages_count(storage, response)
self.assertEqual(cookie_storing, 4)
session_storing = self.stored_session_messages_count(storage, response)
self.assertEqual(session_storing, 1)
def test_session_fallback_only(self):
"""
Large messages, none of which fit in a cookie, are stored in the
SessionBackend (and nothing is stored in the CookieBackend).
"""
storage = self.get_storage()
response = self.get_response()
# Generate the same (tested) content every time that does not get run
# through zlib compression.
random.seed(42)
storage.add(constants.INFO, get_random_string(5000))
storage.update(response)
cookie_storing = self.stored_cookie_messages_count(storage, response)
self.assertEqual(cookie_storing, 0)
session_storing = self.stored_session_messages_count(storage, response)
self.assertEqual(session_storing, 1)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/base.py | tests/messages_tests/base.py | from django.contrib.messages import Message, constants, get_level, set_level
from django.contrib.messages.api import MessageFailure
from django.contrib.messages.constants import DEFAULT_LEVELS
from django.contrib.messages.storage import default_storage
from django.http import HttpRequest, HttpResponse
from django.test import modify_settings, override_settings
from django.urls import reverse
from django.utils.translation import gettext_lazy
def add_level_messages(storage):
"""
Add 6 messages from different levels (including a custom one) to a storage
instance.
"""
storage.add(constants.INFO, "A generic info message")
storage.add(29, "Some custom level")
storage.add(constants.DEBUG, "A debugging message", extra_tags="extra-tag")
storage.add(constants.WARNING, "A warning")
storage.add(constants.ERROR, "An error")
storage.add(constants.SUCCESS, "This was a triumph.")
class BaseTests:
storage_class = default_storage
levels = {
"debug": constants.DEBUG,
"info": constants.INFO,
"success": constants.SUCCESS,
"warning": constants.WARNING,
"error": constants.ERROR,
}
@classmethod
def setUpClass(cls):
cls.enterClassContext(
override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": (
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
),
},
}
],
ROOT_URLCONF="messages_tests.urls",
MESSAGE_TAGS={},
MESSAGE_STORAGE=(
f"{cls.storage_class.__module__}.{cls.storage_class.__name__}"
),
SESSION_SERIALIZER="django.contrib.sessions.serializers.JSONSerializer",
)
)
super().setUpClass()
def get_request(self):
return HttpRequest()
def get_response(self):
return HttpResponse()
def get_storage(self, data=None):
"""
Return the storage backend, setting its loaded data to the ``data``
argument.
This method avoids the storage ``_get`` method from getting called so
that other parts of the storage backend can be tested independent of
the message retrieval logic.
"""
storage = self.storage_class(self.get_request())
storage._loaded_data = data or []
return storage
def test_repr(self):
request = self.get_request()
storage = self.storage_class(request)
self.assertEqual(
repr(storage),
f"<{self.storage_class.__qualname__}: request=<HttpRequest>>",
)
def test_add(self):
storage = self.get_storage()
self.assertFalse(storage.added_new)
storage.add(constants.INFO, "Test message 1")
self.assertTrue(storage.added_new)
storage.add(constants.INFO, "Test message 2", extra_tags="tag")
self.assertEqual(len(storage), 2)
def test_add_lazy_translation(self):
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, gettext_lazy("lazy message"))
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 1)
def test_no_update(self):
storage = self.get_storage()
response = self.get_response()
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 0)
def test_add_update(self):
storage = self.get_storage()
response = self.get_response()
storage.add(constants.INFO, "Test message 1")
storage.add(constants.INFO, "Test message 1", extra_tags="tag")
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 2)
def test_existing_add_read_update(self):
storage = self.get_existing_storage()
response = self.get_response()
storage.add(constants.INFO, "Test message 3")
list(storage) # Simulates a read
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 0)
def test_existing_read_add_update(self):
storage = self.get_existing_storage()
response = self.get_response()
list(storage) # Simulates a read
storage.add(constants.INFO, "Test message 3")
storage.update(response)
storing = self.stored_messages_count(storage, response)
self.assertEqual(storing, 1)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_full_request_response_cycle(self):
"""
With the message middleware enabled, messages are properly stored and
retrieved across the full request/redirect/response cycle.
"""
data = {
"messages": ["Test message %d" % x for x in range(5)],
}
show_url = reverse("show_message")
for level in ("debug", "info", "success", "warning", "error"):
add_url = reverse("add_message", args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertIn("messages", response.context)
messages = [Message(self.levels[level], msg) for msg in data["messages"]]
self.assertEqual(list(response.context["messages"]), messages)
for msg in data["messages"]:
self.assertContains(response, msg)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_with_template_response(self):
data = {
"messages": ["Test message %d" % x for x in range(5)],
}
show_url = reverse("show_template_response")
for level in self.levels:
add_url = reverse("add_template_response", args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertIn("messages", response.context)
for msg in data["messages"]:
self.assertContains(response, msg)
# there shouldn't be any messages on second GET request
response = self.client.get(show_url)
for msg in data["messages"]:
self.assertNotContains(response, msg)
def test_context_processor_message_levels(self):
show_url = reverse("show_template_response")
response = self.client.get(show_url)
self.assertIn("DEFAULT_MESSAGE_LEVELS", response.context)
self.assertEqual(response.context["DEFAULT_MESSAGE_LEVELS"], DEFAULT_LEVELS)
@override_settings(MESSAGE_LEVEL=constants.DEBUG)
def test_multiple_posts(self):
"""
Messages persist properly when multiple POSTs are made before a GET.
"""
data = {
"messages": ["Test message %d" % x for x in range(5)],
}
show_url = reverse("show_message")
messages = []
for level in ("debug", "info", "success", "warning", "error"):
messages.extend(
Message(self.levels[level], msg) for msg in data["messages"]
)
add_url = reverse("add_message", args=(level,))
self.client.post(add_url, data)
response = self.client.get(show_url)
self.assertIn("messages", response.context)
self.assertEqual(list(response.context["messages"]), messages)
for msg in data["messages"]:
self.assertContains(response, msg)
@modify_settings(
INSTALLED_APPS={"remove": "django.contrib.messages"},
MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
)
@override_settings(
MESSAGE_LEVEL=constants.DEBUG,
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
}
],
)
def test_middleware_disabled(self):
"""
When the middleware is disabled, an exception is raised when one
attempts to store a message.
"""
data = {
"messages": ["Test message %d" % x for x in range(5)],
}
reverse("show_message")
for level in ("debug", "info", "success", "warning", "error"):
add_url = reverse("add_message", args=(level,))
with self.assertRaises(MessageFailure):
self.client.post(add_url, data, follow=True)
@modify_settings(
INSTALLED_APPS={"remove": "django.contrib.messages"},
MIDDLEWARE={"remove": "django.contrib.messages.middleware.MessageMiddleware"},
)
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
}
],
)
def test_middleware_disabled_fail_silently(self):
"""
When the middleware is disabled, an exception is not raised
if 'fail_silently' is True.
"""
data = {
"messages": ["Test message %d" % x for x in range(5)],
"fail_silently": True,
}
show_url = reverse("show_message")
for level in ("debug", "info", "success", "warning", "error"):
add_url = reverse("add_message", args=(level,))
response = self.client.post(add_url, data, follow=True)
self.assertRedirects(response, show_url)
self.assertNotIn("messages", response.context)
def stored_messages_count(self, storage, response):
"""
Return the number of messages being stored after a
``storage.update()`` call.
"""
raise NotImplementedError("This method must be set by a subclass.")
def test_get(self):
raise NotImplementedError("This method must be set by a subclass.")
def get_existing_storage(self):
return self.get_storage(
[
Message(constants.INFO, "Test message 1"),
Message(constants.INFO, "Test message 2", extra_tags="tag"),
]
)
def test_existing_read(self):
"""
Reading the existing storage doesn't cause the data to be lost.
"""
storage = self.get_existing_storage()
self.assertFalse(storage.used)
# After iterating the storage engine directly, the used flag is set.
data = list(storage)
self.assertTrue(storage.used)
# The data does not disappear because it has been iterated.
self.assertEqual(data, list(storage))
def test_existing_add(self):
storage = self.get_existing_storage()
self.assertFalse(storage.added_new)
storage.add(constants.INFO, "Test message 3")
self.assertTrue(storage.added_new)
def test_default_level(self):
# get_level works even with no storage on the request.
request = self.get_request()
self.assertEqual(get_level(request), constants.INFO)
# get_level returns the default level if it hasn't been set.
storage = self.get_storage()
request._messages = storage
self.assertEqual(get_level(request), constants.INFO)
# Only messages of sufficient level get recorded.
add_level_messages(storage)
self.assertEqual(len(storage), 5)
def test_low_level(self):
request = self.get_request()
storage = self.storage_class(request)
request._messages = storage
self.assertTrue(set_level(request, 5))
self.assertEqual(get_level(request), 5)
add_level_messages(storage)
self.assertEqual(len(storage), 6)
def test_high_level(self):
request = self.get_request()
storage = self.storage_class(request)
request._messages = storage
self.assertTrue(set_level(request, 30))
self.assertEqual(get_level(request), 30)
add_level_messages(storage)
self.assertEqual(len(storage), 2)
@override_settings(MESSAGE_LEVEL=29)
def test_settings_level(self):
request = self.get_request()
storage = self.storage_class(request)
self.assertEqual(get_level(request), 29)
add_level_messages(storage)
self.assertEqual(len(storage), 3)
def test_tags(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
storage.add(constants.INFO, "A generic info message", extra_tags=None)
tags = [msg.tags for msg in storage]
self.assertEqual(
tags, ["info", "", "extra-tag debug", "warning", "error", "success", "info"]
)
def test_level_tag(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.level_tag for msg in storage]
self.assertEqual(tags, ["info", "", "debug", "warning", "error", "success"])
@override_settings(
MESSAGE_TAGS={
constants.INFO: "info",
constants.DEBUG: "",
constants.WARNING: "",
constants.ERROR: "bad",
29: "custom",
}
)
def test_custom_tags(self):
storage = self.get_storage()
storage.level = 0
add_level_messages(storage)
tags = [msg.tags for msg in storage]
self.assertEqual(tags, ["info", "custom", "extra-tag", "", "bad", "success"])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/messages_tests/urls.py | tests/messages_tests/urls.py | from django import forms
from django.contrib import messages
from django.contrib.messages.views import SuccessMessageMixin
from django.http import HttpResponse, HttpResponseRedirect
from django.template import engines
from django.template.response import TemplateResponse
from django.urls import path, re_path, reverse
from django.views.decorators.cache import never_cache
from django.views.generic.edit import DeleteView, FormView
from .models import SomeObject
TEMPLATE = """{% if messages %}
<ul class="messages">
{% for message in messages %}
<li{% if message.tags %} class="{{ message.tags }}"{% endif %}>
{{ message }}
</li>
{% endfor %}
</ul>
{% endif %}
"""
@never_cache
def add(request, message_type):
# Don't default to False here to test that it defaults to False if
# unspecified.
fail_silently = request.POST.get("fail_silently", None)
for msg in request.POST.getlist("messages"):
if fail_silently is not None:
getattr(messages, message_type)(request, msg, fail_silently=fail_silently)
else:
getattr(messages, message_type)(request, msg)
return HttpResponseRedirect(reverse("show_message"))
@never_cache
def add_template_response(request, message_type):
for msg in request.POST.getlist("messages"):
getattr(messages, message_type)(request, msg)
return HttpResponseRedirect(reverse("show_template_response"))
@never_cache
def show(request):
template = engines["django"].from_string(TEMPLATE)
return HttpResponse(template.render(request=request))
@never_cache
def show_template_response(request):
template = engines["django"].from_string(TEMPLATE)
return TemplateResponse(request, template)
class ContactForm(forms.Form):
name = forms.CharField(required=True)
slug = forms.SlugField(required=True)
class ContactFormViewWithMsg(SuccessMessageMixin, FormView):
form_class = ContactForm
success_url = show
success_message = "%(name)s was created successfully"
class DeleteFormViewWithMsg(SuccessMessageMixin, DeleteView):
model = SomeObject
success_url = "/show/"
success_message = "Object was deleted successfully"
urlpatterns = [
re_path("^add/(debug|info|success|warning|error)/$", add, name="add_message"),
path("add/msg/", ContactFormViewWithMsg.as_view(), name="add_success_msg"),
path(
"delete/msg/<int:pk>",
DeleteFormViewWithMsg.as_view(),
name="success_msg_on_delete",
),
path("show/", show, name="show_message"),
re_path(
"^template_response/add/(debug|info|success|warning|error)/$",
add_template_response,
name="add_template_response",
),
path(
"template_response/show/", show_template_response, name="show_template_response"
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_meta/results.py | tests/model_meta/results.py | from .models import AbstractPerson, BasePerson, Person, ProxyPerson, Relating, Relation
TEST_RESULTS = {
"get_all_field_names": {
Person: [
"baseperson_ptr",
"baseperson_ptr_id",
"content_type_abstract",
"content_type_abstract_id",
"content_type_base",
"content_type_base_id",
"content_type_concrete",
"content_type_concrete_id",
"data_abstract",
"data_base",
"data_inherited",
"data_not_concrete_abstract",
"data_not_concrete_base",
"data_not_concrete_inherited",
"fk_abstract",
"fk_abstract_id",
"fk_base",
"fk_base_id",
"fk_inherited",
"fk_inherited_id",
"followers_abstract",
"followers_base",
"followers_concrete",
"following_abstract",
"following_base",
"following_inherited",
"friends_abstract",
"friends_base",
"friends_inherited",
"generic_relation_abstract",
"generic_relation_base",
"generic_relation_concrete",
"id",
"m2m_abstract",
"m2m_base",
"m2m_inherited",
"object_id_abstract",
"object_id_base",
"object_id_concrete",
"relating_basepeople",
"relating_baseperson",
"relating_people",
"relating_person",
],
BasePerson: [
"content_type_abstract",
"content_type_abstract_id",
"content_type_base",
"content_type_base_id",
"data_abstract",
"data_base",
"data_not_concrete_abstract",
"data_not_concrete_base",
"fk_abstract",
"fk_abstract_id",
"fk_base",
"fk_base_id",
"followers_abstract",
"followers_base",
"following_abstract",
"following_base",
"friends_abstract",
"friends_base",
"generic_relation_abstract",
"generic_relation_base",
"id",
"m2m_abstract",
"m2m_base",
"object_id_abstract",
"object_id_base",
"person",
"relating_basepeople",
"relating_baseperson",
],
AbstractPerson: [
"content_type_abstract",
"content_type_abstract_id",
"data_abstract",
"data_not_concrete_abstract",
"fk_abstract",
"fk_abstract_id",
"following_abstract",
"friends_abstract",
"generic_relation_abstract",
"m2m_abstract",
"object_id_abstract",
],
Relating: [
"basepeople",
"basepeople_hidden",
"baseperson",
"baseperson_hidden",
"baseperson_hidden_id",
"baseperson_id",
"id",
"people",
"people_hidden",
"person",
"person_hidden",
"person_hidden_id",
"person_id",
"proxyperson",
"proxyperson_hidden",
"proxyperson_hidden_id",
"proxyperson_id",
],
},
"fields": {
Person: [
"id",
"data_abstract",
"fk_abstract_id",
"data_not_concrete_abstract",
"content_type_abstract_id",
"object_id_abstract",
"data_base",
"fk_base_id",
"data_not_concrete_base",
"content_type_base_id",
"object_id_base",
"baseperson_ptr_id",
"data_inherited",
"fk_inherited_id",
"data_not_concrete_inherited",
"content_type_concrete_id",
"object_id_concrete",
],
BasePerson: [
"id",
"data_abstract",
"fk_abstract_id",
"data_not_concrete_abstract",
"content_type_abstract_id",
"object_id_abstract",
"data_base",
"fk_base_id",
"data_not_concrete_base",
"content_type_base_id",
"object_id_base",
],
AbstractPerson: [
"data_abstract",
"fk_abstract_id",
"data_not_concrete_abstract",
"content_type_abstract_id",
"object_id_abstract",
],
Relating: [
"id",
"baseperson_id",
"baseperson_hidden_id",
"person_id",
"person_hidden_id",
"proxyperson_id",
"proxyperson_hidden_id",
],
},
"local_fields": {
Person: [
"baseperson_ptr_id",
"data_inherited",
"fk_inherited_id",
"data_not_concrete_inherited",
"content_type_concrete_id",
"object_id_concrete",
],
BasePerson: [
"id",
"data_abstract",
"fk_abstract_id",
"data_not_concrete_abstract",
"content_type_abstract_id",
"object_id_abstract",
"data_base",
"fk_base_id",
"data_not_concrete_base",
"content_type_base_id",
"object_id_base",
],
AbstractPerson: [
"data_abstract",
"fk_abstract_id",
"data_not_concrete_abstract",
"content_type_abstract_id",
"object_id_abstract",
],
Relating: [
"id",
"baseperson_id",
"baseperson_hidden_id",
"person_id",
"person_hidden_id",
"proxyperson_id",
"proxyperson_hidden_id",
],
},
"local_concrete_fields": {
Person: [
"baseperson_ptr_id",
"data_inherited",
"fk_inherited_id",
"content_type_concrete_id",
"object_id_concrete",
],
BasePerson: [
"id",
"data_abstract",
"fk_abstract_id",
"content_type_abstract_id",
"object_id_abstract",
"data_base",
"fk_base_id",
"content_type_base_id",
"object_id_base",
],
AbstractPerson: [
"data_abstract",
"fk_abstract_id",
"content_type_abstract_id",
"object_id_abstract",
],
Relating: [
"id",
"baseperson_id",
"baseperson_hidden_id",
"person_id",
"person_hidden_id",
"proxyperson_id",
"proxyperson_hidden_id",
],
},
"many_to_many": {
Person: [
"m2m_abstract",
"friends_abstract",
"following_abstract",
"m2m_base",
"friends_base",
"following_base",
"m2m_inherited",
"friends_inherited",
"following_inherited",
],
BasePerson: [
"m2m_abstract",
"friends_abstract",
"following_abstract",
"m2m_base",
"friends_base",
"following_base",
],
AbstractPerson: [
"m2m_abstract",
"friends_abstract",
"following_abstract",
],
Relating: [
"basepeople",
"basepeople_hidden",
"people",
"people_hidden",
],
},
"many_to_many_with_model": {
Person: [
BasePerson,
BasePerson,
BasePerson,
BasePerson,
BasePerson,
BasePerson,
None,
None,
None,
],
BasePerson: [
None,
None,
None,
None,
None,
None,
],
AbstractPerson: [
None,
None,
None,
],
Relating: [
None,
None,
None,
None,
],
},
"get_all_related_objects_with_model_legacy": {
Person: (
("relating_baseperson", BasePerson),
("relating_person", None),
),
BasePerson: (
("person", None),
("relating_baseperson", None),
),
Relation: (
("fk_abstract_rel", None),
("fo_abstract_rel", None),
("fk_base_rel", None),
("fo_base_rel", None),
("fk_concrete_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_objects_with_model_hidden_local": {
Person: (
("+", None),
("_model_meta_relating_people_hidden_+", None),
("Person_following_inherited+", None),
("Person_following_inherited+", None),
("Person_friends_inherited+", None),
("Person_friends_inherited+", None),
("Person_m2m_inherited+", None),
("Relating_people+", None),
("Relating_people_hidden+", None),
("followers_concrete", None),
("friends_inherited_rel_+", None),
("personthroughproxysubclass", None),
("relating_people", None),
("relating_person", None),
("relating_proxyperson", None),
("relating_proxyperson_hidden+", None),
),
ProxyPerson: (
("+", Person),
("_model_meta_relating_people_hidden_+", Person),
("Person_following_inherited+", Person),
("Person_following_inherited+", Person),
("Person_friends_inherited+", Person),
("Person_friends_inherited+", Person),
("Person_m2m_inherited+", Person),
("Relating_people+", Person),
("Relating_people_hidden+", Person),
("followers_concrete", Person),
("friends_inherited_rel_+", Person),
("personthroughproxysubclass", Person),
("relating_people", Person),
("relating_person", Person),
("relating_proxyperson", Person),
("relating_proxyperson_hidden+", Person),
),
BasePerson: (
("+", None),
("_model_meta_relating_basepeople_hidden_+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_base+", None),
("BasePerson_following_base+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_base+", None),
("BasePerson_friends_base+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Relating_basepeople+", None),
("Relating_basepeople_hidden+", None),
("followers_abstract", None),
("followers_base", None),
("friends_abstract_rel_+", None),
("friends_base_rel_+", None),
("person", None),
("relating_basepeople", None),
("relating_baseperson", None),
),
Relation: (
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Person_m2m_inherited+", None),
("fk_abstract_rel", None),
("fk_base_rel", None),
("fk_concrete_rel", None),
("fo_abstract_rel", None),
("fo_base_rel", None),
("fo_concrete_rel", None),
("m2m_abstract_rel", None),
("m2m_base_rel", None),
("m2m_concrete_rel", None),
),
},
"get_all_related_objects_with_model_hidden": {
Person: (
("+", BasePerson),
("+", None),
("_model_meta_relating_basepeople_hidden_+", BasePerson),
("_model_meta_relating_people_hidden_+", None),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_m2m_abstract+", BasePerson),
("BasePerson_m2m_base+", BasePerson),
("Person_following_inherited+", None),
("Person_following_inherited+", None),
("Person_friends_inherited+", None),
("Person_friends_inherited+", None),
("Person_m2m_inherited+", None),
("Relating_basepeople+", BasePerson),
("Relating_basepeople_hidden+", BasePerson),
("Relating_people+", None),
("Relating_people_hidden+", None),
("followers_abstract", BasePerson),
("followers_base", BasePerson),
("followers_concrete", None),
("friends_abstract_rel_+", BasePerson),
("friends_base_rel_+", BasePerson),
("friends_inherited_rel_+", None),
("personthroughproxysubclass", None),
("relating_basepeople", BasePerson),
("relating_baseperson", BasePerson),
("relating_people", None),
("relating_person", None),
("relating_proxyperson", None),
("relating_proxyperson_hidden+", None),
),
ProxyPerson: (
("+", BasePerson),
("+", Person),
("_model_meta_relating_basepeople_hidden_+", BasePerson),
("_model_meta_relating_people_hidden_+", Person),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_m2m_abstract+", BasePerson),
("BasePerson_m2m_base+", BasePerson),
("Person_following_inherited+", Person),
("Person_following_inherited+", Person),
("Person_friends_inherited+", Person),
("Person_friends_inherited+", Person),
("Person_m2m_inherited+", Person),
("Relating_basepeople+", BasePerson),
("Relating_basepeople_hidden+", BasePerson),
("Relating_people+", Person),
("Relating_people_hidden+", Person),
("followers_abstract", BasePerson),
("followers_base", BasePerson),
("followers_concrete", Person),
("friends_abstract_rel_+", BasePerson),
("friends_base_rel_+", BasePerson),
("friends_inherited_rel_+", Person),
("personthroughproxysubclass", Person),
("relating_basepeople", BasePerson),
("relating_baseperson", BasePerson),
("relating_people", Person),
("relating_person", Person),
("relating_proxyperson", Person),
("relating_proxyperson_hidden+", Person),
),
BasePerson: (
("+", None),
("_model_meta_relating_basepeople_hidden_+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_base+", None),
("BasePerson_following_base+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_base+", None),
("BasePerson_friends_base+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Relating_basepeople+", None),
("Relating_basepeople_hidden+", None),
("followers_abstract", None),
("followers_base", None),
("friends_abstract_rel_+", None),
("friends_base_rel_+", None),
("person", None),
("relating_basepeople", None),
("relating_baseperson", None),
),
Relation: (
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Person_m2m_inherited+", None),
("fk_abstract_rel", None),
("fk_base_rel", None),
("fk_concrete_rel", None),
("fo_abstract_rel", None),
("fo_base_rel", None),
("fo_concrete_rel", None),
("m2m_abstract_rel", None),
("m2m_base_rel", None),
("m2m_concrete_rel", None),
),
},
"get_all_related_objects_with_model_local": {
Person: (
("followers_concrete", None),
("personthroughproxysubclass", None),
("relating_person", None),
("relating_people", None),
("relating_proxyperson", None),
),
ProxyPerson: (
("followers_concrete", Person),
("personthroughproxysubclass", Person),
("relating_person", Person),
("relating_people", Person),
("relating_proxyperson", Person),
),
BasePerson: (
("followers_abstract", None),
("followers_base", None),
("person", None),
("relating_baseperson", None),
("relating_basepeople", None),
),
Relation: (
("fk_abstract_rel", None),
("fo_abstract_rel", None),
("fk_base_rel", None),
("fo_base_rel", None),
("m2m_abstract_rel", None),
("m2m_base_rel", None),
("fk_concrete_rel", None),
("fo_concrete_rel", None),
("m2m_concrete_rel", None),
),
},
"get_all_related_objects_with_model": {
Person: (
("followers_abstract", BasePerson),
("followers_base", BasePerson),
("relating_baseperson", BasePerson),
("relating_basepeople", BasePerson),
("followers_concrete", None),
("personthroughproxysubclass", None),
("relating_person", None),
("relating_people", None),
("relating_proxyperson", None),
),
ProxyPerson: (
("followers_abstract", BasePerson),
("followers_base", BasePerson),
("relating_baseperson", BasePerson),
("relating_basepeople", BasePerson),
("followers_concrete", Person),
("personthroughproxysubclass", Person),
("relating_person", Person),
("relating_people", Person),
("relating_proxyperson", Person),
),
BasePerson: (
("followers_abstract", None),
("followers_base", None),
("person", None),
("relating_baseperson", None),
("relating_basepeople", None),
),
Relation: (
("fk_abstract_rel", None),
("fo_abstract_rel", None),
("fk_base_rel", None),
("fo_base_rel", None),
("m2m_abstract_rel", None),
("m2m_base_rel", None),
("fk_concrete_rel", None),
("fo_concrete_rel", None),
("m2m_concrete_rel", None),
),
},
"get_all_related_objects_with_model_local_legacy": {
Person: (("relating_person", None),),
BasePerson: (("person", None), ("relating_baseperson", None)),
Relation: (
("fk_abstract_rel", None),
("fo_abstract_rel", None),
("fk_base_rel", None),
("fo_base_rel", None),
("fk_concrete_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_objects_with_model_hidden_legacy": {
BasePerson: (
("+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_base+", None),
("BasePerson_following_base+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_base+", None),
("BasePerson_friends_base+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Relating_basepeople+", None),
("Relating_basepeople_hidden+", None),
("person", None),
("relating_baseperson", None),
),
Person: (
("+", BasePerson),
("+", None),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_m2m_abstract+", BasePerson),
("BasePerson_m2m_base+", BasePerson),
("Person_following_inherited+", None),
("Person_following_inherited+", None),
("Person_friends_inherited+", None),
("Person_friends_inherited+", None),
("Person_m2m_inherited+", None),
("Relating_basepeople+", BasePerson),
("Relating_basepeople_hidden+", BasePerson),
("Relating_people+", None),
("Relating_people_hidden+", None),
("relating_baseperson", BasePerson),
("relating_person", None),
),
Relation: (
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Person_m2m_inherited+", None),
("fk_abstract_rel", None),
("fk_base_rel", None),
("fk_concrete_rel", None),
("fo_abstract_rel", None),
("fo_base_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_objects_with_model_hidden_local_legacy": {
BasePerson: (
("+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_base+", None),
("BasePerson_following_base+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_base+", None),
("BasePerson_friends_base+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Relating_basepeople+", None),
("Relating_basepeople_hidden+", None),
("person", None),
("relating_baseperson", None),
),
Person: (
("+", None),
("Person_following_inherited+", None),
("Person_following_inherited+", None),
("Person_friends_inherited+", None),
("Person_friends_inherited+", None),
("Person_m2m_inherited+", None),
("Relating_people+", None),
("Relating_people_hidden+", None),
("relating_person", None),
),
Relation: (
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Person_m2m_inherited+", None),
("fk_abstract_rel", None),
("fk_base_rel", None),
("fk_concrete_rel", None),
("fo_abstract_rel", None),
("fo_base_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_objects_with_model_proxy_legacy": {
BasePerson: (
("person", None),
("relating_baseperson", None),
),
Person: (
("relating_baseperson", BasePerson),
("relating_person", None),
("relating_proxyperson", None),
),
Relation: (
("fk_abstract_rel", None),
("fo_abstract_rel", None),
("fk_base_rel", None),
("fo_base_rel", None),
("fk_concrete_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_objects_with_model_proxy_hidden_legacy": {
BasePerson: (
("+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_abstract+", None),
("BasePerson_following_base+", None),
("BasePerson_following_base+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_abstract+", None),
("BasePerson_friends_base+", None),
("BasePerson_friends_base+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Relating_basepeople+", None),
("Relating_basepeople_hidden+", None),
("person", None),
("relating_baseperson", None),
),
Person: (
("+", BasePerson),
("+", None),
("+", None),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_abstract+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_following_base+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_abstract+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_friends_base+", BasePerson),
("BasePerson_m2m_abstract+", BasePerson),
("BasePerson_m2m_base+", BasePerson),
("Person_following_inherited+", None),
("Person_following_inherited+", None),
("Person_friends_inherited+", None),
("Person_friends_inherited+", None),
("Person_m2m_inherited+", None),
("Relating_basepeople+", BasePerson),
("Relating_basepeople_hidden+", BasePerson),
("Relating_people+", None),
("Relating_people_hidden+", None),
("relating_baseperson", BasePerson),
("relating_person", None),
("relating_proxyperson", None),
),
Relation: (
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("+", None),
("BasePerson_m2m_abstract+", None),
("BasePerson_m2m_base+", None),
("Person_m2m_inherited+", None),
("fk_abstract_rel", None),
("fk_base_rel", None),
("fk_concrete_rel", None),
("fo_abstract_rel", None),
("fo_base_rel", None),
("fo_concrete_rel", None),
),
},
"get_all_related_many_to_many_with_model_legacy": {
BasePerson: (
("friends_abstract_rel_+", None),
("followers_abstract", None),
("friends_base_rel_+", None),
("followers_base", None),
("relating_basepeople", None),
("_model_meta_relating_basepeople_hidden_+", None),
),
Person: (
("friends_abstract_rel_+", BasePerson),
("followers_abstract", BasePerson),
("friends_base_rel_+", BasePerson),
("followers_base", BasePerson),
("relating_basepeople", BasePerson),
("_model_meta_relating_basepeople_hidden_+", BasePerson),
("friends_inherited_rel_+", None),
("followers_concrete", None),
("relating_people", None),
("_relating_people_hidden_+", None),
),
Relation: (
("m2m_abstract_rel", None),
("m2m_base_rel", None),
("m2m_concrete_rel", None),
),
},
"get_all_related_many_to_many_local_legacy": {
BasePerson: [
"friends_abstract_rel_+",
"followers_abstract",
"friends_base_rel_+",
"followers_base",
"relating_basepeople",
"_model_meta_relating_basepeople_hidden_+",
],
Person: [
"friends_inherited_rel_+",
"followers_concrete",
"relating_people",
"_relating_people_hidden_+",
],
Relation: [
"m2m_abstract_rel",
"m2m_base_rel",
"m2m_concrete_rel",
],
},
"private_fields": {
AbstractPerson: [
"generic_relation_abstract",
"content_object_abstract",
],
BasePerson: [
"generic_relation_base",
"content_object_base",
"generic_relation_abstract",
"content_object_abstract",
],
Person: [
"content_object_concrete",
"generic_relation_concrete",
"generic_relation_base",
"content_object_base",
"generic_relation_abstract",
"content_object_abstract",
],
},
"labels": {
AbstractPerson: "model_meta.AbstractPerson",
BasePerson: "model_meta.BasePerson",
Person: "model_meta.Person",
Relating: "model_meta.Relating",
},
"lower_labels": {
AbstractPerson: "model_meta.abstractperson",
BasePerson: "model_meta.baseperson",
Person: "model_meta.person",
Relating: "model_meta.relating",
},
}
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_meta/models.py | tests/model_meta/models.py | from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.utils.translation import gettext_lazy as _
class Relation(models.Model):
pass
class InstanceOnlyDescriptor:
def __get__(self, instance, cls=None):
if instance is None:
raise AttributeError("Instance only")
return 1
class AbstractPerson(models.Model):
# DATA fields
data_abstract = models.CharField(max_length=10)
fk_abstract = models.ForeignKey(
Relation, models.CASCADE, related_name="fk_abstract_rel"
)
# M2M fields
m2m_abstract = models.ManyToManyField(Relation, related_name="m2m_abstract_rel")
friends_abstract = models.ManyToManyField("self", symmetrical=True)
following_abstract = models.ManyToManyField(
"self", related_name="followers_abstract", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_abstract = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=["abstract_non_concrete_id"],
to_fields=["id"],
related_name="fo_abstract_rel",
)
# GFK fields
content_type_abstract = models.ForeignKey(
ContentType, models.CASCADE, related_name="+"
)
object_id_abstract = models.PositiveIntegerField()
content_object_abstract = GenericForeignKey(
"content_type_abstract", "object_id_abstract"
)
# GR fields
generic_relation_abstract = GenericRelation(Relation)
class Meta:
abstract = True
@property
def test_property(self):
return 1
test_instance_only_descriptor = InstanceOnlyDescriptor()
class BasePerson(AbstractPerson):
# DATA fields
data_base = models.CharField(max_length=10)
fk_base = models.ForeignKey(Relation, models.CASCADE, related_name="fk_base_rel")
# M2M fields
m2m_base = models.ManyToManyField(Relation, related_name="m2m_base_rel")
friends_base = models.ManyToManyField("self", symmetrical=True)
following_base = models.ManyToManyField(
"self", related_name="followers_base", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_base = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=["base_non_concrete_id"],
to_fields=["id"],
related_name="fo_base_rel",
)
# GFK fields
content_type_base = models.ForeignKey(ContentType, models.CASCADE, related_name="+")
object_id_base = models.PositiveIntegerField()
content_object_base = GenericForeignKey("content_type_base", "object_id_base")
# GR fields
generic_relation_base = GenericRelation(Relation)
class Person(BasePerson):
# DATA fields
data_inherited = models.CharField(max_length=10)
fk_inherited = models.ForeignKey(
Relation, models.CASCADE, related_name="fk_concrete_rel"
)
# M2M Fields
m2m_inherited = models.ManyToManyField(Relation, related_name="m2m_concrete_rel")
friends_inherited = models.ManyToManyField("self", symmetrical=True)
following_inherited = models.ManyToManyField(
"self", related_name="followers_concrete", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_inherited = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=["model_non_concrete_id"],
to_fields=["id"],
related_name="fo_concrete_rel",
)
# GFK fields
content_type_concrete = models.ForeignKey(
ContentType, models.CASCADE, related_name="+"
)
object_id_concrete = models.PositiveIntegerField()
content_object_concrete = GenericForeignKey(
"content_type_concrete", "object_id_concrete"
)
# GR fields
generic_relation_concrete = GenericRelation(Relation)
class Meta:
verbose_name = _("Person")
class ProxyPerson(Person):
class Meta:
proxy = True
class PersonThroughProxySubclass(ProxyPerson):
pass
class Relating(models.Model):
# ForeignKey to BasePerson
baseperson = models.ForeignKey(
BasePerson, models.CASCADE, related_name="relating_baseperson"
)
baseperson_hidden = models.ForeignKey(BasePerson, models.CASCADE, related_name="+")
# ForeignKey to Person
person = models.ForeignKey(Person, models.CASCADE, related_name="relating_person")
person_hidden = models.ForeignKey(Person, models.CASCADE, related_name="+")
# ForeignKey to ProxyPerson
proxyperson = models.ForeignKey(
ProxyPerson, models.CASCADE, related_name="relating_proxyperson"
)
proxyperson_hidden = models.ForeignKey(
ProxyPerson, models.CASCADE, related_name="relating_proxyperson_hidden+"
)
# ManyToManyField to BasePerson
basepeople = models.ManyToManyField(BasePerson, related_name="relating_basepeople")
basepeople_hidden = models.ManyToManyField(BasePerson, related_name="+")
# ManyToManyField to Person
people = models.ManyToManyField(Person, related_name="relating_people")
people_hidden = models.ManyToManyField(Person, related_name="+")
class Swappable(models.Model):
class Meta:
swappable = "MODEL_META_TESTS_SWAPPED"
# ParentListTests models
class CommonAncestor(models.Model):
pass
class FirstParent(CommonAncestor):
first_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class SecondParent(CommonAncestor):
second_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class Child(FirstParent, SecondParent):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_meta/__init__.py | tests/model_meta/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_meta/tests.py | tests/model_meta/tests.py | from django.apps import apps
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.core.exceptions import FieldDoesNotExist
from django.db.models import CharField, Field, ForeignObjectRel, ManyToManyField
from django.db.models.options import EMPTY_RELATION_TREE, IMMUTABLE_WARNING
from django.test import SimpleTestCase, override_settings
from .models import (
AbstractPerson,
BasePerson,
Child,
CommonAncestor,
FirstParent,
Person,
ProxyPerson,
Relating,
Relation,
SecondParent,
Swappable,
)
from .results import TEST_RESULTS
class OptionsBaseTests(SimpleTestCase):
def _map_related_query_names(self, res):
return tuple((o.name, m) for o, m in res)
def _map_names(self, res):
return tuple((f.name, m) for f, m in res)
def _model(self, current_model, field):
model = field.model._meta.concrete_model
return None if model == current_model else model
def _details(self, current_model, relation):
direct = isinstance(relation, (Field, GenericForeignKey))
model = relation.model._meta.concrete_model
if model == current_model:
model = None
field = relation if direct else relation.field
return (
relation,
model,
direct,
bool(field.many_to_many),
) # many_to_many can be None
class GetFieldsTests(OptionsBaseTests):
def test_get_fields_is_immutable(self):
msg = IMMUTABLE_WARNING % "get_fields()"
for _ in range(2):
# Running unit test twice to ensure both non-cached and cached
# result are immutable.
fields = Person._meta.get_fields()
with self.assertRaisesMessage(AttributeError, msg):
fields += ["errors"]
class LabelTests(OptionsBaseTests):
def test_label(self):
for model, expected_result in TEST_RESULTS["labels"].items():
self.assertEqual(model._meta.label, expected_result)
def test_label_lower(self):
for model, expected_result in TEST_RESULTS["lower_labels"].items():
self.assertEqual(model._meta.label_lower, expected_result)
class DataTests(OptionsBaseTests):
def test_fields(self):
for model, expected_result in TEST_RESULTS["fields"].items():
fields = model._meta.fields
self.assertEqual([f.attname for f in fields], expected_result)
def test_local_fields(self):
def is_data_field(f):
return isinstance(f, Field) and not f.many_to_many
for model, expected_result in TEST_RESULTS["local_fields"].items():
fields = model._meta.local_fields
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
self.assertEqual(f.model, model)
self.assertTrue(is_data_field(f))
def test_local_concrete_fields(self):
for model, expected_result in TEST_RESULTS["local_concrete_fields"].items():
fields = model._meta.local_concrete_fields
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
self.assertIsNotNone(f.column)
class M2MTests(OptionsBaseTests):
def test_many_to_many(self):
for model, expected_result in TEST_RESULTS["many_to_many"].items():
fields = model._meta.many_to_many
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
self.assertTrue(f.many_to_many and f.is_relation)
def test_many_to_many_with_model(self):
for model, expected_result in TEST_RESULTS["many_to_many_with_model"].items():
models = [self._model(model, field) for field in model._meta.many_to_many]
self.assertEqual(models, expected_result)
class RelatedObjectsTests(OptionsBaseTests):
def key_name(self, r):
return r[0]
def test_related_objects(self):
result_key = "get_all_related_objects_with_model"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
for field in model._meta.get_fields()
if field.auto_created and not field.concrete
]
self.assertEqual(
sorted(self._map_related_query_names(objects), key=self.key_name),
sorted(expected, key=self.key_name),
)
def test_related_objects_local(self):
result_key = "get_all_related_objects_with_model_local"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
for field in model._meta.get_fields(include_parents=False)
if field.auto_created and not field.concrete
]
self.assertEqual(
sorted(self._map_related_query_names(objects), key=self.key_name),
sorted(expected, key=self.key_name),
)
def test_related_objects_include_hidden(self):
result_key = "get_all_related_objects_with_model_hidden"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
for field in model._meta.get_fields(include_hidden=True)
if field.auto_created and not field.concrete
]
self.assertEqual(
sorted(self._map_names(objects), key=self.key_name),
sorted(expected, key=self.key_name),
)
def test_related_objects_include_hidden_local_only(self):
result_key = "get_all_related_objects_with_model_hidden_local"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
for field in model._meta.get_fields(
include_hidden=True, include_parents=False
)
if field.auto_created and not field.concrete
]
self.assertEqual(
sorted(self._map_names(objects), key=self.key_name),
sorted(expected, key=self.key_name),
)
class PrivateFieldsTests(OptionsBaseTests):
def test_private_fields(self):
for model, expected_names in TEST_RESULTS["private_fields"].items():
objects = model._meta.private_fields
self.assertEqual(sorted(f.name for f in objects), sorted(expected_names))
class GetFieldByNameTests(OptionsBaseTests):
def test_get_data_field(self):
field_info = self._details(Person, Person._meta.get_field("data_abstract"))
self.assertEqual(field_info[1:], (BasePerson, True, False))
self.assertIsInstance(field_info[0], CharField)
def test_get_m2m_field(self):
field_info = self._details(Person, Person._meta.get_field("m2m_base"))
self.assertEqual(field_info[1:], (BasePerson, True, True))
self.assertIsInstance(field_info[0], ManyToManyField)
def test_get_related_object(self):
field_info = self._details(
Person, Person._meta.get_field("relating_baseperson")
)
self.assertEqual(field_info[1:], (BasePerson, False, False))
self.assertIsInstance(field_info[0], ForeignObjectRel)
def test_get_related_m2m(self):
field_info = self._details(Person, Person._meta.get_field("relating_people"))
self.assertEqual(field_info[1:], (None, False, True))
self.assertIsInstance(field_info[0], ForeignObjectRel)
def test_get_generic_relation(self):
field_info = self._details(
Person, Person._meta.get_field("generic_relation_base")
)
self.assertEqual(field_info[1:], (None, True, False))
self.assertIsInstance(field_info[0], GenericRelation)
def test_get_fields_only_searches_forward_on_apps_not_ready(self):
opts = Person._meta
# If apps registry is not ready, get_field() searches over only
# forward fields.
opts.apps.models_ready = False
try:
# 'data_abstract' is a forward field, and therefore will be found
self.assertTrue(opts.get_field("data_abstract"))
msg = (
"Person has no field named 'relating_baseperson'. The app "
"cache isn't ready yet, so if this is an auto-created related "
"field, it won't be available yet."
)
# 'data_abstract' is a reverse field, and will raise an exception
with self.assertRaisesMessage(FieldDoesNotExist, msg):
opts.get_field("relating_baseperson")
finally:
opts.apps.models_ready = True
class VerboseNameRawTests(SimpleTestCase):
def test_string(self):
# Clear cached property.
Relation._meta.__dict__.pop("verbose_name_raw", None)
self.assertEqual(Relation._meta.verbose_name_raw, "relation")
def test_gettext(self):
Person._meta.__dict__.pop("verbose_name_raw", None)
self.assertEqual(Person._meta.verbose_name_raw, "Person")
class SwappedTests(SimpleTestCase):
def test_plain_model_none(self):
self.assertIsNone(Relation._meta.swapped)
def test_unset(self):
self.assertIsNone(Swappable._meta.swapped)
def test_set_and_unset(self):
with override_settings(MODEL_META_TESTS_SWAPPED="model_meta.Relation"):
self.assertEqual(Swappable._meta.swapped, "model_meta.Relation")
self.assertIsNone(Swappable._meta.swapped)
def test_setting_none(self):
with override_settings(MODEL_META_TESTS_SWAPPED=None):
self.assertIsNone(Swappable._meta.swapped)
def test_setting_non_label(self):
with override_settings(MODEL_META_TESTS_SWAPPED="not-a-label"):
self.assertEqual(Swappable._meta.swapped, "not-a-label")
def test_setting_self(self):
with override_settings(MODEL_META_TESTS_SWAPPED="model_meta.swappable"):
self.assertIsNone(Swappable._meta.swapped)
class RelationTreeTests(SimpleTestCase):
all_models = (Relation, AbstractPerson, BasePerson, Person, ProxyPerson, Relating)
def setUp(self):
apps.clear_cache()
def test_clear_cache_clears_relation_tree(self):
# The apps.clear_cache is setUp() should have deleted all trees.
# Exclude abstract models that are not included in the Apps registry
# and have no cache.
all_models_with_cache = (m for m in self.all_models if not m._meta.abstract)
for m in all_models_with_cache:
self.assertNotIn("_relation_tree", m._meta.__dict__)
def test_first_relation_tree_access_populates_all(self):
# On first access, relation tree should have populated cache.
self.assertTrue(self.all_models[0]._meta._relation_tree)
# AbstractPerson does not have any relations, so relation_tree
# should just return an EMPTY_RELATION_TREE.
self.assertEqual(AbstractPerson._meta._relation_tree, EMPTY_RELATION_TREE)
# All the other models should already have their relation tree
# in the internal __dict__ .
all_models_but_abstractperson = (
m for m in self.all_models if m is not AbstractPerson
)
for m in all_models_but_abstractperson:
self.assertIn("_relation_tree", m._meta.__dict__)
def test_relations_related_objects(self):
# Testing non hidden related objects
self.assertEqual(
sorted(
field.related_query_name()
for field in Relation._meta._relation_tree
if not field.remote_field.field.remote_field.hidden
),
sorted(
[
"fk_abstract_rel",
"fk_base_rel",
"fk_concrete_rel",
"fo_abstract_rel",
"fo_base_rel",
"fo_concrete_rel",
"m2m_abstract_rel",
"m2m_base_rel",
"m2m_concrete_rel",
]
),
)
# Testing hidden related objects
self.assertEqual(
sorted(
field.related_query_name() for field in BasePerson._meta._relation_tree
),
sorted(
[
"+",
"_model_meta_relating_basepeople_hidden_+",
"BasePerson_following_abstract+",
"BasePerson_following_abstract+",
"BasePerson_following_base+",
"BasePerson_following_base+",
"BasePerson_friends_abstract+",
"BasePerson_friends_abstract+",
"BasePerson_friends_base+",
"BasePerson_friends_base+",
"BasePerson_m2m_abstract+",
"BasePerson_m2m_base+",
"Relating_basepeople+",
"Relating_basepeople_hidden+",
"followers_abstract",
"followers_base",
"friends_abstract_rel_+",
"friends_base_rel_+",
"person",
"relating_basepeople",
"relating_baseperson",
]
),
)
self.assertEqual(
[
field.related_query_name()
for field in AbstractPerson._meta._relation_tree
],
[],
)
class AllParentsTests(SimpleTestCase):
def test_all_parents(self):
self.assertEqual(CommonAncestor._meta.all_parents, ())
self.assertEqual(FirstParent._meta.all_parents, (CommonAncestor,))
self.assertEqual(SecondParent._meta.all_parents, (CommonAncestor,))
self.assertEqual(
Child._meta.all_parents,
(FirstParent, SecondParent, CommonAncestor),
)
def test_get_parent_list(self):
self.assertEqual(Child._meta.get_parent_list(), list(Child._meta.all_parents))
class PropertyNamesTests(SimpleTestCase):
def test_person(self):
# Instance only descriptors don't appear in _property_names.
self.assertEqual(BasePerson().test_instance_only_descriptor, 1)
with self.assertRaisesMessage(AttributeError, "Instance only"):
AbstractPerson.test_instance_only_descriptor
self.assertEqual(
AbstractPerson._meta._property_names, frozenset(["pk", "test_property"])
)
class ReturningFieldsTests(SimpleTestCase):
def test_pk(self):
self.assertEqual(Relation._meta.db_returning_fields, [Relation._meta.pk])
class AbstractModelTests(SimpleTestCase):
def test_abstract_model_not_instantiated(self):
msg = "Abstract models cannot be instantiated."
with self.assertRaisesMessage(TypeError, msg):
AbstractPerson()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/save_delete_hooks/models.py | tests/save_delete_hooks/models.py | """
Adding hooks before/after saving and deleting
To execute arbitrary code around ``save()`` and ``delete()``, just subclass
the methods.
"""
from django.db import models
class Person(models.Model):
first_name = models.CharField(max_length=20)
last_name = models.CharField(max_length=20)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.data = []
def __str__(self):
return "%s %s" % (self.first_name, self.last_name)
def save(self, *args, **kwargs):
self.data.append("Before save")
# Call the "real" save() method
super().save(*args, **kwargs)
self.data.append("After save")
def delete(self):
self.data.append("Before deletion")
# Call the "real" delete() method
super().delete()
self.data.append("After deletion")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/save_delete_hooks/__init__.py | tests/save_delete_hooks/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/save_delete_hooks/tests.py | tests/save_delete_hooks/tests.py | from django.test import TestCase
from .models import Person
class SaveDeleteHookTests(TestCase):
def test_basic(self):
p = Person(first_name="John", last_name="Smith")
self.assertEqual(p.data, [])
p.save()
self.assertEqual(
p.data,
[
"Before save",
"After save",
],
)
self.assertQuerySetEqual(
Person.objects.all(),
[
"John Smith",
],
str,
)
p.delete()
self.assertEqual(
p.data,
[
"Before save",
"After save",
"Before deletion",
"After deletion",
],
)
self.assertQuerySetEqual(Person.objects.all(), [])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/validators/__init__.py | tests/validators/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/validators/tests.py | tests/validators/tests.py | import ipaddress
import re
import types
from datetime import datetime, timedelta
from decimal import Decimal
from unittest import TestCase, mock
from django.core.exceptions import ValidationError
from django.core.files.base import ContentFile
from django.core.validators import (
BaseValidator,
DecimalValidator,
DomainNameValidator,
EmailValidator,
FileExtensionValidator,
MaxLengthValidator,
MaxValueValidator,
MinLengthValidator,
MinValueValidator,
ProhibitNullCharactersValidator,
RegexValidator,
StepValueValidator,
URLValidator,
int_list_validator,
validate_comma_separated_integer_list,
validate_domain_name,
validate_email,
validate_image_file_extension,
validate_integer,
validate_ipv4_address,
validate_ipv6_address,
validate_ipv46_address,
validate_slug,
validate_unicode_slug,
)
from django.test import SimpleTestCase
try:
from PIL import Image # noqa
except ImportError:
PILLOW_IS_INSTALLED = False
else:
PILLOW_IS_INSTALLED = True
NOW = datetime.now()
EXTENDED_SCHEMES = ["http", "https", "ftp", "ftps", "git", "file", "git+ssh"]
VALID_URLS = [
"http://www.djangoproject.com/",
"HTTP://WWW.DJANGOPROJECT.COM/",
"http://localhost/",
"http://example.com/",
"http://example.com:0",
"http://example.com:0/",
"http://example.com:65535",
"http://example.com:65535/",
"http://example.com./",
"http://www.example.com/",
"http://www.example.com:8000/test",
"http://valid-with-hyphens.com/",
"http://subdomain.example.com/",
"http://a.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"http://200.8.9.10/",
"http://200.8.9.10:8000/test",
"http://su--b.valid-----hyphens.com/",
"http://example.com?something=value",
"http://example.com/index.php?something=value&another=value2",
"https://example.com/",
"ftp://example.com/",
"ftps://example.com/",
"http://foo.com/blah_blah",
"http://foo.com/blah_blah/",
"http://foo.com/blah_blah_(wikipedia)",
"http://foo.com/blah_blah_(wikipedia)_(again)",
"http://www.example.com/wpstyle/?p=364",
"https://www.example.com/foo/?bar=baz&inga=42&quux",
"http://✪df.ws/123",
"http://userid@example.com",
"http://userid@example.com/",
"http://userid@example.com:8080",
"http://userid@example.com:8080/",
"http://userid@example.com:65535",
"http://userid@example.com:65535/",
"http://userid:@example.com",
"http://userid:@example.com/",
"http://userid:@example.com:8080",
"http://userid:@example.com:8080/",
"http://userid:password@example.com",
"http://userid:password@example.com/",
"http://userid:password@example.com:8",
"http://userid:password@example.com:8/",
"http://userid:password@example.com:8080",
"http://userid:password@example.com:8080/",
"http://userid:password@example.com:65535",
"http://userid:password@example.com:65535/",
"https://userid:paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaassword@example.com",
"https://userid:paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaassword@example.com:8080",
"https://useridddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"dddddddddddddddddddddd:password@example.com",
"https://useridddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
"ddddddddddddddddd:password@example.com:8080",
"http://userid:password" + "d" * 2000 + "@example.aaaaaaaaaaaaa.com",
"http://142.42.1.1/",
"http://142.42.1.1:8080/",
"http://➡.ws/䨹",
"http://⌘.ws",
"http://⌘.ws/",
"http://foo.com/blah_(wikipedia)#cite-1",
"http://foo.com/blah_(wikipedia)_blah#cite-1",
"http://foo.com/unicode_(✪)_in_parens",
"http://foo.com/(something)?after=parens",
"http://☺.damowmow.com/",
"http://djangoproject.com/events/#&product=browser",
"http://j.mp",
"ftp://foo.bar/baz",
"http://foo.bar/?q=Test%20URL-encoded%20stuff",
"http://مثال.إختبار",
"http://例子.测试",
"http://उदाहरण.परीक्षा",
"https://މިހާރު.com", # (valid in IDNA 2008 but not IDNA 2003)
"http://-.~_!$&'()*+,;=%40:80%2f@example.com",
"http://xn--7sbb4ac0ad0be6cf.xn--p1ai",
"http://1337.net",
"http://a.b-c.de",
"http://223.255.255.254",
"ftps://foo.bar/",
"http://10.1.1.254",
"http://[FEDC:BA98:7654:3210:FEDC:BA98:7654:3210]:80/index.html",
"http://[::192.9.5.5]/ipng",
"http://[::ffff:192.9.5.5]/ipng",
"http://[::1]:8080/",
"http://0.0.0.0/",
"http://255.255.255.255",
"http://224.0.0.0",
"http://224.1.1.1",
"http://111.112.113.114/",
"http://88.88.88.88/",
"http://11.12.13.14/",
"http://10.20.30.40/",
"http://1.2.3.4/",
"http://127.0.01.09.home.lan",
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ex"
"ample.com",
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaa.com",
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"http://dashintld.c-m",
"http://multipledashintld.a-b-c",
"http://evenmoredashintld.a---c",
"http://dashinpunytld.xn---c",
]
INVALID_URLS = [
None,
56,
"no_scheme",
"foo",
"http://",
"http://example",
"http://example.",
"http://example.com:-1",
"http://example.com:-1/",
"http://example.com:000000080",
"http://example.com:000000080/",
"http://.com",
"http://invalid-.com",
"http://-invalid.com",
"http://invalid.com-",
"http://invalid.-com",
"http://inv-.alid-.com",
"http://inv-.-alid.com",
"file://localhost/path",
"git://example.com/",
"http://.",
"http://..",
"http://../",
"http://?",
"http://??",
"http://??/",
"http://#",
"http://##",
"http://##/",
"http://foo.bar?q=Spaces should be encoded",
"//",
"//a",
"///a",
"///",
"http:///a",
"foo.com",
"rdar://1234",
"h://test",
"http:// shouldfail.com",
":// should fail",
"http://foo.bar/foo(bar)baz quux",
"http://-error-.invalid/",
"http://dashinpunytld.trailingdot.xn--.",
"http://dashinpunytld.xn---",
"http://-a.b.co",
"http://a.b-.co",
"http://a.-b.co",
"http://a.b-.c.co",
"http:/",
"http://",
"http://",
"http://1.1.1.1.1",
"http://123.123.123",
"http://3628126748",
"http://123",
"http://000.000.000.000",
"http://016.016.016.016",
"http://192.168.000.001",
"http://01.2.3.4",
"http://01.2.3.4",
"http://1.02.3.4",
"http://1.2.03.4",
"http://1.2.3.04",
"http://.www.foo.bar/",
"http://.www.foo.bar./",
"http://[::1:2::3]:8/",
"http://[::1:2::3]:8080/",
"http://[]",
"http://[]:8080",
"http://example..com/",
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.e"
"xample.com",
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaa.com",
"http://example.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaa",
"http://example." + ("a" * 63 + ".") * 1000 + "com",
"http://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaa."
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaa",
"https://test.[com",
"http://@example.com",
"http://:@example.com",
"http://:bar@example.com",
"http://foo@bar@example.com",
"http://foo/bar@example.com",
"http://foo:bar:baz@example.com",
"http://foo:bar@baz@example.com",
"http://foo:bar/baz@example.com",
"http://invalid-.com/?m=foo@example.com",
# Newlines and tabs are not accepted.
"http://www.djangoproject.com/\n",
"http://[::ffff:192.9.5.5]\n",
"http://www.djangoproject.com/\r",
"http://[::ffff:192.9.5.5]\r",
"http://www.django\rproject.com/",
"http://[::\rffff:192.9.5.5]",
"http://\twww.djangoproject.com/",
"http://\t[::ffff:192.9.5.5]",
# Trailing junk does not take forever to reject.
"http://www.asdasdasdasdsadfm.com.br ",
"http://www.asdasdasdasdsadfm.com.br z",
]
TEST_DATA = [
# (validator, value, expected),
(validate_integer, "42", None),
(validate_integer, "-42", None),
(validate_integer, -42, None),
(validate_integer, -42.5, ValidationError),
(validate_integer, None, ValidationError),
(validate_integer, "a", ValidationError),
(validate_integer, "\n42", ValidationError),
(validate_integer, "42\n", ValidationError),
(validate_email, "email@here.com", None),
(validate_email, "weirder-email@here.and.there.com", None),
(validate_email, "email@[127.0.0.1]", None),
(validate_email, "email@[2001:dB8::1]", None),
(validate_email, "email@[2001:dB8:0:0:0:0:0:1]", None),
(validate_email, "email@[::fffF:127.0.0.1]", None),
(validate_email, "example@valid-----hyphens.com", None),
(validate_email, "example@valid-with-hyphens.com", None),
(validate_email, "test@domain.with.idn.tld.उदाहरण.परीक्षा", None),
(validate_email, "email@localhost", None),
(EmailValidator(allowlist=["localdomain"]), "email@localdomain", None),
(validate_email, '"test@test"@example.com', None),
(validate_email, "example@atm.%s" % ("a" * 63), None),
(validate_email, "example@%s.atm" % ("a" * 63), None),
(validate_email, "example@%s.%s.atm" % ("a" * 63, "b" * 10), None),
(validate_email, "example@atm.%s" % ("a" * 64), ValidationError),
(validate_email, "example@%s.atm.%s" % ("b" * 64, "a" * 63), ValidationError),
(validate_email, "example@%scom" % (("a" * 63 + ".") * 100), ValidationError),
(validate_email, None, ValidationError),
(validate_email, "", ValidationError),
(validate_email, "abc", ValidationError),
(validate_email, "abc@", ValidationError),
(validate_email, "abc@bar", ValidationError),
(validate_email, "a @x.cz", ValidationError),
(validate_email, "abc@.com", ValidationError),
(validate_email, "something@@somewhere.com", ValidationError),
(validate_email, "email@127.0.0.1", ValidationError),
(validate_email, "email@[127.0.0.256]", ValidationError),
(validate_email, "email@[2001:db8::12345]", ValidationError),
(validate_email, "email@[2001:db8:0:0:0:0:1]", ValidationError),
(validate_email, "email@[::ffff:127.0.0.256]", ValidationError),
(validate_email, "email@[2001:dg8::1]", ValidationError),
(validate_email, "email@[2001:dG8:0:0:0:0:0:1]", ValidationError),
(validate_email, "email@[::fTzF:127.0.0.1]", ValidationError),
(validate_email, "example@invalid-.com", ValidationError),
(validate_email, "example@-invalid.com", ValidationError),
(validate_email, "example@invalid.com-", ValidationError),
(validate_email, "example@inv-.alid-.com", ValidationError),
(validate_email, "example@inv-.-alid.com", ValidationError),
(validate_email, 'test@example.com\n\n<script src="x.js">', ValidationError),
(validate_email, "email@xn--4ca9at.com", None),
(validate_email, "email@öäü.com", None),
(validate_email, "email@עִתוֹן.example.il", None),
(validate_email, "email@މިހާރު.example.mv", None),
(validate_email, "email@漢字.example.com", None),
(validate_email, "editor@މިހާރު.example.mv", None),
(validate_email, "@domain.com", ValidationError),
(validate_email, "email.domain.com", ValidationError),
(validate_email, "email@domain@domain.com", ValidationError),
(validate_email, "email@domain..com", ValidationError),
(validate_email, "email@.domain.com", ValidationError),
(validate_email, "email@-domain.com", ValidationError),
(validate_email, "email@domain-.com", ValidationError),
(validate_email, "email@domain.com-", ValidationError),
# Quoted-string format (CR not allowed)
(validate_email, '"\\\011"@here.com', None),
(validate_email, '"\\\012"@here.com', ValidationError),
(validate_email, "trailingdot@shouldfail.com.", ValidationError),
# Max length of domain name labels is 63 characters per RFC 1034.
(validate_email, "a@%s.us" % ("a" * 63), None),
(validate_email, "a@%s.us" % ("a" * 64), ValidationError),
# Trailing newlines in username or domain not allowed
(validate_email, "a@b.com\n", ValidationError),
(validate_email, "a\n@b.com", ValidationError),
(validate_email, '"test@test"\n@example.com', ValidationError),
(validate_email, "a@[127.0.0.1]\n", ValidationError),
(validate_slug, "slug-ok", None),
(validate_slug, "longer-slug-still-ok", None),
(validate_slug, "--------", None),
(validate_slug, "nohyphensoranything", None),
(validate_slug, "a", None),
(validate_slug, "1", None),
(validate_slug, "a1", None),
(validate_slug, "", ValidationError),
(validate_slug, " text ", ValidationError),
(validate_slug, " ", ValidationError),
(validate_slug, "some@mail.com", ValidationError),
(validate_slug, "你好", ValidationError),
(validate_slug, "你 好", ValidationError),
(validate_slug, "\n", ValidationError),
(validate_slug, "trailing-newline\n", ValidationError),
(validate_unicode_slug, "slug-ok", None),
(validate_unicode_slug, "longer-slug-still-ok", None),
(validate_unicode_slug, "--------", None),
(validate_unicode_slug, "nohyphensoranything", None),
(validate_unicode_slug, "a", None),
(validate_unicode_slug, "1", None),
(validate_unicode_slug, "a1", None),
(validate_unicode_slug, "你好", None),
(validate_unicode_slug, "", ValidationError),
(validate_unicode_slug, " text ", ValidationError),
(validate_unicode_slug, " ", ValidationError),
(validate_unicode_slug, "some@mail.com", ValidationError),
(validate_unicode_slug, "\n", ValidationError),
(validate_unicode_slug, "你 好", ValidationError),
(validate_unicode_slug, "trailing-newline\n", ValidationError),
(validate_ipv4_address, "1.1.1.1", None),
(validate_ipv4_address, "255.0.0.0", None),
(validate_ipv4_address, "0.0.0.0", None),
(validate_ipv4_address, "256.1.1.1", ValidationError),
(validate_ipv4_address, "25.1.1.", ValidationError),
(validate_ipv4_address, "25,1,1,1", ValidationError),
(validate_ipv4_address, "25.1 .1.1", ValidationError),
(validate_ipv4_address, "1.1.1.1\n", ValidationError),
(validate_ipv4_address, "٧.2٥.3٣.243", ValidationError),
# Leading zeros are forbidden to avoid ambiguity with the octal notation.
(validate_ipv4_address, "000.000.000.000", ValidationError),
(validate_ipv4_address, "016.016.016.016", ValidationError),
(validate_ipv4_address, "192.168.000.001", ValidationError),
(validate_ipv4_address, "01.2.3.4", ValidationError),
(validate_ipv4_address, "01.2.3.4", ValidationError),
(validate_ipv4_address, "1.02.3.4", ValidationError),
(validate_ipv4_address, "1.2.03.4", ValidationError),
(validate_ipv4_address, "1.2.3.04", ValidationError),
# validate_ipv6_address uses django.utils.ipv6, which
# is tested in much greater detail in its own testcase
(validate_ipv6_address, "fe80::1", None),
(validate_ipv6_address, "::1", None),
(validate_ipv6_address, "1:2:3:4:5:6:7:8", None),
(validate_ipv6_address, ipaddress.IPv6Address("::ffff:2.125.160.216"), None),
(validate_ipv6_address, ipaddress.IPv6Address("fe80::1"), None),
(validate_ipv6_address, Decimal("33.1"), ValidationError),
(validate_ipv6_address, 9.22, ValidationError),
(validate_ipv6_address, "1:2", ValidationError),
(validate_ipv6_address, "::zzz", ValidationError),
(validate_ipv6_address, "12345::", ValidationError),
(validate_ipv46_address, "1.1.1.1", None),
(validate_ipv46_address, "255.0.0.0", None),
(validate_ipv46_address, "0.0.0.0", None),
(validate_ipv46_address, ipaddress.IPv4Address("1.1.1.1"), None),
(validate_ipv46_address, ipaddress.IPv4Address("255.0.0.0"), None),
(validate_ipv46_address, "fe80::1", None),
(validate_ipv46_address, "::1", None),
(validate_ipv46_address, "1:2:3:4:5:6:7:8", None),
(validate_ipv46_address, ipaddress.IPv6Address("::ffff:2.125.160.216"), None),
(validate_ipv46_address, ipaddress.IPv6Address("fe80::1"), None),
(validate_ipv46_address, Decimal("33.1"), ValidationError),
(validate_ipv46_address, 9.22, ValidationError),
(validate_ipv46_address, "256.1.1.1", ValidationError),
(validate_ipv46_address, "25.1.1.", ValidationError),
(validate_ipv46_address, "25,1,1,1", ValidationError),
(validate_ipv46_address, "25.1 .1.1", ValidationError),
(validate_ipv46_address, "1:2", ValidationError),
(validate_ipv46_address, "::zzz", ValidationError),
(validate_ipv46_address, "12345::", ValidationError),
# Leading zeros are forbidden to avoid ambiguity with the octal notation.
(validate_ipv46_address, "000.000.000.000", ValidationError),
(validate_ipv46_address, "016.016.016.016", ValidationError),
(validate_ipv46_address, "192.168.000.001", ValidationError),
(validate_ipv46_address, "01.2.3.4", ValidationError),
(validate_ipv46_address, "01.2.3.4", ValidationError),
(validate_ipv46_address, "1.02.3.4", ValidationError),
(validate_ipv46_address, "1.2.03.4", ValidationError),
(validate_ipv46_address, "1.2.3.04", ValidationError),
(validate_comma_separated_integer_list, "1", None),
(validate_comma_separated_integer_list, "12", None),
(validate_comma_separated_integer_list, "1,2", None),
(validate_comma_separated_integer_list, "1,2,3", None),
(validate_comma_separated_integer_list, "10,32", None),
(validate_comma_separated_integer_list, "", ValidationError),
(validate_comma_separated_integer_list, "a", ValidationError),
(validate_comma_separated_integer_list, "a,b,c", ValidationError),
(validate_comma_separated_integer_list, "1, 2, 3", ValidationError),
(validate_comma_separated_integer_list, ",", ValidationError),
(validate_comma_separated_integer_list, "1,2,3,", ValidationError),
(validate_comma_separated_integer_list, "1,2,", ValidationError),
(validate_comma_separated_integer_list, ",1", ValidationError),
(validate_comma_separated_integer_list, "1,,2", ValidationError),
(int_list_validator(sep="."), "1.2.3", None),
(int_list_validator(sep=".", allow_negative=True), "1.2.3", None),
(int_list_validator(allow_negative=True), "-1,-2,3", None),
(int_list_validator(allow_negative=True), "1,-2,-12", None),
(int_list_validator(), "-1,2,3", ValidationError),
(int_list_validator(sep="."), "1,2,3", ValidationError),
(int_list_validator(sep="."), "1.2.3\n", ValidationError),
(MaxValueValidator(10), 10, None),
(MaxValueValidator(10), -10, None),
(MaxValueValidator(10), 0, None),
(MaxValueValidator(NOW), NOW, None),
(MaxValueValidator(NOW), NOW - timedelta(days=1), None),
(MaxValueValidator(0), 1, ValidationError),
(MaxValueValidator(NOW), NOW + timedelta(days=1), ValidationError),
(MinValueValidator(-10), -10, None),
(MinValueValidator(-10), 10, None),
(MinValueValidator(-10), 0, None),
(MinValueValidator(NOW), NOW, None),
(MinValueValidator(NOW), NOW + timedelta(days=1), None),
(MinValueValidator(0), -1, ValidationError),
(MinValueValidator(NOW), NOW - timedelta(days=1), ValidationError),
# limit_value may be a callable.
(MinValueValidator(lambda: 1), 0, ValidationError),
(MinValueValidator(lambda: 1), 1, None),
(StepValueValidator(3), 0, None),
(MaxLengthValidator(10), "", None),
(MaxLengthValidator(10), 10 * "x", None),
(MaxLengthValidator(10), 15 * "x", ValidationError),
(MinLengthValidator(10), 15 * "x", None),
(MinLengthValidator(10), 10 * "x", None),
(MinLengthValidator(10), "", ValidationError),
(StepValueValidator(3), 1, ValidationError),
(StepValueValidator(3), 8, ValidationError),
(StepValueValidator(3), 9, None),
(StepValueValidator(2), 4, None),
(StepValueValidator(2, offset=1), 3, None),
(StepValueValidator(2, offset=1), 4, ValidationError),
(StepValueValidator(0.001), 0.55, None),
(StepValueValidator(0.001), 0.5555, ValidationError),
(StepValueValidator(0.001, offset=0.0005), 0.5555, None),
(StepValueValidator(0.001, offset=0.0005), 0.555, ValidationError),
(StepValueValidator(Decimal(0.02)), 0.88, None),
(StepValueValidator(Decimal(0.02)), Decimal(0.88), None),
(StepValueValidator(Decimal(0.02)), Decimal(0.77), ValidationError),
(StepValueValidator(Decimal(0.02), offset=Decimal(0.01)), Decimal(0.77), None),
(StepValueValidator(Decimal(2.0), offset=Decimal(0.1)), Decimal(0.1), None),
(
StepValueValidator(Decimal(0.02), offset=Decimal(0.01)),
Decimal(0.88),
ValidationError,
),
(StepValueValidator(Decimal("1.2"), offset=Decimal("2.2")), Decimal("3.4"), None),
(
StepValueValidator(Decimal("1.2"), offset=Decimal("2.2")),
Decimal("1.2"),
ValidationError,
),
(
StepValueValidator(Decimal("-1.2"), offset=Decimal("2.2")),
Decimal("1.1"),
ValidationError,
),
(
StepValueValidator(Decimal("-1.2"), offset=Decimal("2.2")),
Decimal("1.0"),
None,
),
(URLValidator(EXTENDED_SCHEMES), "file://localhost/path", None),
(URLValidator(EXTENDED_SCHEMES), "git://example.com/", None),
(
URLValidator(EXTENDED_SCHEMES),
"git+ssh://git@github.com/example/hg-git.git",
None,
),
(URLValidator(EXTENDED_SCHEMES), "git://-invalid.com", ValidationError),
(BaseValidator(True), True, None),
(BaseValidator(True), False, ValidationError),
(RegexValidator(), "", None),
(RegexValidator(), "x1x2", None),
(RegexValidator("[0-9]+"), "xxxxxx", ValidationError),
(RegexValidator("[0-9]+"), "1234", None),
(RegexValidator(re.compile("[0-9]+")), "1234", None),
(RegexValidator(".*"), "", None),
(RegexValidator(re.compile(".*")), "", None),
(RegexValidator(".*"), "xxxxx", None),
(RegexValidator("x"), "y", ValidationError),
(RegexValidator(re.compile("x")), "y", ValidationError),
(RegexValidator("x", inverse_match=True), "y", None),
(RegexValidator(re.compile("x"), inverse_match=True), "y", None),
(RegexValidator("x", inverse_match=True), "x", ValidationError),
(RegexValidator(re.compile("x"), inverse_match=True), "x", ValidationError),
(RegexValidator("x", flags=re.IGNORECASE), "y", ValidationError),
(RegexValidator("a"), "A", ValidationError),
(RegexValidator("a", flags=re.IGNORECASE), "A", None),
(
FileExtensionValidator(["txt"]),
ContentFile("contents", name="fileWithUnsupportedExt.jpg"),
ValidationError,
),
(
FileExtensionValidator(["txt"]),
ContentFile("contents", name="fileWithUnsupportedExt.JPG"),
ValidationError,
),
(
FileExtensionValidator(["txt"]),
ContentFile("contents", name="fileWithNoExtension"),
ValidationError,
),
(
FileExtensionValidator([""]),
ContentFile("contents", name="fileWithAnExtension.txt"),
ValidationError,
),
(
FileExtensionValidator([]),
ContentFile("contents", name="file.txt"),
ValidationError,
),
(
FileExtensionValidator([""]),
ContentFile("contents", name="fileWithNoExtension"),
None,
),
(FileExtensionValidator(["txt"]), ContentFile("contents", name="file.txt"), None),
(FileExtensionValidator(["txt"]), ContentFile("contents", name="file.TXT"), None),
(FileExtensionValidator(["TXT"]), ContentFile("contents", name="file.txt"), None),
(FileExtensionValidator(), ContentFile("contents", name="file.jpg"), None),
(DecimalValidator(max_digits=2, decimal_places=2), Decimal("0.99"), None),
(
DecimalValidator(max_digits=2, decimal_places=1),
Decimal("0.99"),
ValidationError,
),
(DecimalValidator(max_digits=3, decimal_places=1), Decimal("999"), ValidationError),
(DecimalValidator(max_digits=4, decimal_places=1), Decimal("999"), None),
(
DecimalValidator(max_digits=20, decimal_places=2),
Decimal("742403889818000000"),
None,
),
(DecimalValidator(20, 2), Decimal("7.42403889818E+17"), None),
(
DecimalValidator(max_digits=20, decimal_places=2),
Decimal("7424742403889818000000"),
ValidationError,
),
(DecimalValidator(max_digits=5, decimal_places=2), Decimal("7304E-1"), None),
(
DecimalValidator(max_digits=5, decimal_places=2),
Decimal("7304E-3"),
ValidationError,
),
(DecimalValidator(max_digits=5, decimal_places=5), Decimal("70E-5"), None),
(
DecimalValidator(max_digits=5, decimal_places=5),
Decimal("70E-6"),
ValidationError,
),
(DecimalValidator(max_digits=2, decimal_places=1), Decimal("0E+1"), None),
# 'Enter a number.' errors
*[
(
DecimalValidator(decimal_places=2, max_digits=10),
Decimal(value),
ValidationError,
)
for value in (
"NaN",
"-NaN",
"+NaN",
"sNaN",
"-sNaN",
"+sNaN",
"Inf",
"-Inf",
"+Inf",
"Infinity",
"-Infinity",
"+Infinity",
)
],
(validate_image_file_extension, ContentFile("contents", name="file.jpg"), None),
(validate_image_file_extension, ContentFile("contents", name="file.png"), None),
(validate_image_file_extension, ContentFile("contents", name="file.PNG"), None),
(
validate_image_file_extension,
ContentFile("contents", name="file.txt"),
ValidationError,
),
(
validate_image_file_extension,
ContentFile("contents", name="file"),
ValidationError,
),
(ProhibitNullCharactersValidator(), "\x00something", ValidationError),
(ProhibitNullCharactersValidator(), "something", None),
(ProhibitNullCharactersValidator(), None, None),
(validate_domain_name, "000000.org", None),
(validate_domain_name, "python.org", None),
(validate_domain_name, "python.co.uk", None),
(validate_domain_name, "python.tk", None),
(validate_domain_name, "domain.with.idn.tld.उदाहरण.परीक्ष", None),
(validate_domain_name, "ıçğü.com", None),
(validate_domain_name, "xn--7ca6byfyc.com", None),
(validate_domain_name, "hg.python.org", None),
(validate_domain_name, "python.xyz", None),
(validate_domain_name, "djangoproject.com", None),
(validate_domain_name, "DJANGOPROJECT.COM", None),
(validate_domain_name, "spam.eggs", None),
(validate_domain_name, "python-python.com", None),
(validate_domain_name, "python.name.uk", None),
(validate_domain_name, "python.tips", None),
(validate_domain_name, "例子.测试", None),
(validate_domain_name, "dashinpunytld.xn---c", None),
(validate_domain_name, "python..org", ValidationError),
(validate_domain_name, "python-.org", ValidationError),
(validate_domain_name, "too-long-name." * 20 + "com", ValidationError),
(validate_domain_name, "stupid-name试", ValidationError),
(validate_domain_name, "255.0.0.0", ValidationError),
(validate_domain_name, "fe80::1", ValidationError),
(validate_domain_name, "1:2:3:4:5:6:7:8", ValidationError),
(DomainNameValidator(accept_idna=False), "non-idna-domain-name-passes.com", None),
(
DomainNameValidator(accept_idna=False),
"domain.with.idn.tld.उदाहरण.परीक्ष",
ValidationError,
),
(DomainNameValidator(accept_idna=False), "ıçğü.com", ValidationError),
(DomainNameValidator(accept_idna=False), "not-domain-name", ValidationError),
(
DomainNameValidator(accept_idna=False),
"not-domain-name, but-has-domain-name-suffix.com",
ValidationError,
),
(
DomainNameValidator(accept_idna=False),
"not-domain-name.com, but has domain prefix",
ValidationError,
),
]
# Add valid and invalid URL tests.
# This only tests the validator without extended schemes.
TEST_DATA.extend((URLValidator(), url, None) for url in VALID_URLS)
TEST_DATA.extend((URLValidator(), url, ValidationError) for url in INVALID_URLS)
class TestValidators(SimpleTestCase):
def test_validators(self):
for validator, value, expected in TEST_DATA:
name = (
validator.__name__
if isinstance(validator, types.FunctionType)
else validator.__class__.__name__
)
exception_expected = expected is not None and issubclass(
expected, Exception
)
with self.subTest(name, value=value):
if (
validator is validate_image_file_extension
and not PILLOW_IS_INSTALLED
):
self.skipTest(
"Pillow is required to test validate_image_file_extension."
)
if exception_expected:
with self.assertRaises(expected):
validator(value)
else:
self.assertEqual(expected, validator(value))
def test_single_message(self):
v = ValidationError("Not Valid")
self.assertEqual(str(v), "['Not Valid']")
self.assertEqual(repr(v), "ValidationError(['Not Valid'])")
def test_message_list(self):
v = ValidationError(["First Problem", "Second Problem"])
self.assertEqual(str(v), "['First Problem', 'Second Problem']")
self.assertEqual(
repr(v), "ValidationError(['First Problem', 'Second Problem'])"
)
def test_message_dict(self):
v = ValidationError({"first": ["First Problem"]})
self.assertEqual(str(v), "{'first': ['First Problem']}")
self.assertEqual(repr(v), "ValidationError({'first': ['First Problem']})")
def test_regex_validator_flags(self):
msg = "If the flags are set, regex must be a regular expression string."
with self.assertRaisesMessage(TypeError, msg):
RegexValidator(re.compile("a"), flags=re.IGNORECASE)
def test_max_length_validator_message(self):
v = MaxLengthValidator(
16, message='"%(value)s" has more than %(limit_value)d characters.'
)
with self.assertRaisesMessage(
ValidationError, '"djangoproject.com" has more than 16 characters.'
):
v("djangoproject.com")
class TestValidatorEquality(TestCase):
"""
Validators have valid equality operators (#21638)
"""
def test_regex_equality(self):
self.assertEqual(
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
)
self.assertNotEqual(
RegexValidator(r"^(?:[a-z0-9.-]*)://"),
RegexValidator(r"^(?:[0-9.-]*)://"),
)
self.assertEqual(
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh noes", "invalid"),
)
self.assertNotEqual(
RegexValidator(r"^(?:[a-z0-9.-]*)://", "oh", "invalid"),
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/shortcuts/views.py | tests/shortcuts/views.py | from django.shortcuts import render
def render_view(request):
return render(
request,
"shortcuts/render_test.html",
{
"foo": "FOO",
"bar": "BAR",
},
)
def render_view_with_multiple_templates(request):
return render(
request,
[
"shortcuts/no_such_template.html",
"shortcuts/render_test.html",
],
{
"foo": "FOO",
"bar": "BAR",
},
)
def render_view_with_content_type(request):
return render(
request,
"shortcuts/render_test.html",
{
"foo": "FOO",
"bar": "BAR",
},
content_type="application/x-rendertest",
)
def render_view_with_status(request):
return render(
request,
"shortcuts/render_test.html",
{
"foo": "FOO",
"bar": "BAR",
},
status=403,
)
def render_view_with_using(request):
using = request.GET.get("using")
return render(request, "shortcuts/using.html", using=using)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/shortcuts/__init__.py | tests/shortcuts/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/shortcuts/tests.py | tests/shortcuts/tests.py | from django.http.response import HttpResponseRedirectBase
from django.shortcuts import redirect
from django.test import SimpleTestCase, override_settings
from django.test.utils import require_jinja2
@override_settings(ROOT_URLCONF="shortcuts.urls")
class RenderTests(SimpleTestCase):
def test_render(self):
response = self.client.get("/render/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"FOO.BAR../render/\n")
self.assertEqual(response.headers["Content-Type"], "text/html; charset=utf-8")
self.assertFalse(hasattr(response.context.request, "current_app"))
def test_render_with_multiple_templates(self):
response = self.client.get("/render/multiple_templates/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"FOO.BAR../render/multiple_templates/\n")
def test_render_with_content_type(self):
response = self.client.get("/render/content_type/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"FOO.BAR../render/content_type/\n")
self.assertEqual(response.headers["Content-Type"], "application/x-rendertest")
def test_render_with_status(self):
response = self.client.get("/render/status/")
self.assertEqual(response.status_code, 403)
self.assertEqual(response.content, b"FOO.BAR../render/status/\n")
@require_jinja2
def test_render_with_using(self):
response = self.client.get("/render/using/")
self.assertEqual(response.content, b"DTL\n")
response = self.client.get("/render/using/?using=django")
self.assertEqual(response.content, b"DTL\n")
response = self.client.get("/render/using/?using=jinja2")
self.assertEqual(response.content, b"Jinja2\n")
class RedirectTests(SimpleTestCase):
def test_redirect_response_status_code(self):
tests = [
(True, False, 301),
(False, False, 302),
(False, True, 307),
(True, True, 308),
]
for permanent, preserve_request, expected_status_code in tests:
with self.subTest(permanent=permanent, preserve_request=preserve_request):
response = redirect(
"/path/is/irrelevant/",
permanent=permanent,
preserve_request=preserve_request,
)
self.assertIsInstance(response, HttpResponseRedirectBase)
self.assertEqual(response.status_code, expected_status_code)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/shortcuts/urls.py | tests/shortcuts/urls.py | from django.urls import path
from . import views
urlpatterns = [
path("render/", views.render_view),
path("render/multiple_templates/", views.render_view_with_multiple_templates),
path("render/content_type/", views.render_view_with_content_type),
path("render/status/", views.render_view_with_status),
path("render/using/", views.render_view_with_using),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_named_urls.py | tests/urlpatterns_reverse/included_named_urls.py | from django.urls import include, path, re_path
from .views import empty_view
urlpatterns = [
path("", empty_view, name="named-url3"),
re_path(r"^extra/(?P<extra>\w+)/$", empty_view, name="named-url4"),
re_path(r"^(?P<one>[0-9]+)|(?P<two>[0-9]+)/$", empty_view),
path("included/", include("urlpatterns_reverse.included_named_urls2")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/no_urls.py | tests/urlpatterns_reverse/no_urls.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/namespace_urls.py | tests/urlpatterns_reverse/namespace_urls.py | from django.urls import include, path, re_path
from . import views
from .utils import URLObject
testobj1 = URLObject("testapp", "test-ns1")
testobj2 = URLObject("testapp", "test-ns2")
default_testobj = URLObject("testapp", "testapp")
otherobj1 = URLObject("nodefault", "other-ns1")
otherobj2 = URLObject("nodefault", "other-ns2")
newappobj1 = URLObject("newapp")
app_name = "namespace_urls"
urlpatterns = [
path("normal/", views.empty_view, name="normal-view"),
re_path(
r"^normal/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.empty_view,
name="normal-view",
),
path("resolver_match/", views.pass_resolver_match_view, name="test-resolver-match"),
re_path(r"^\+\\\$\*/$", views.empty_view, name="special-view"),
re_path(
r"^mixed_args/([0-9]+)/(?P<arg2>[0-9]+)/$",
views.empty_view,
{"extra": True},
name="mixed-args",
),
re_path(r"^no_kwargs/([0-9]+)/([0-9]+)/$", views.empty_view, name="no-kwargs"),
re_path(
r"^view_class/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.view_class_instance,
name="view-class",
),
re_path(r"^unnamed/normal/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$", views.empty_view),
re_path(
r"^unnamed/view_class/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.view_class_instance,
),
path("test1/", include(*testobj1.urls)),
path("test2/", include(*testobj2.urls)),
path("default/", include(*default_testobj.urls)),
path("other1/", include(*otherobj1.urls)),
re_path(r"^other[246]/", include(*otherobj2.urls)),
path("newapp1/", include(newappobj1.app_urls, "new-ns1")),
path("new-default/", include(newappobj1.app_urls)),
re_path(
r"^app-included[135]/",
include("urlpatterns_reverse.included_app_urls", namespace="app-ns1"),
),
path(
"app-included2/",
include("urlpatterns_reverse.included_app_urls", namespace="app-ns2"),
),
re_path(
r"^ns-included[135]/",
include("urlpatterns_reverse.included_namespace_urls", namespace="inc-ns1"),
),
path(
"ns-included2/",
include("urlpatterns_reverse.included_namespace_urls", namespace="inc-ns2"),
),
path(
"app-included/",
include("urlpatterns_reverse.included_namespace_urls", "inc-app"),
),
path("included/", include("urlpatterns_reverse.included_namespace_urls")),
re_path(
r"^inc(?P<outer>[0-9]+)/",
include(
("urlpatterns_reverse.included_urls", "included_urls"), namespace="inc-ns5"
),
),
re_path(
r"^included/([0-9]+)/", include("urlpatterns_reverse.included_namespace_urls")
),
re_path(
r"^ns-outer/(?P<outer>[0-9]+)/",
include("urlpatterns_reverse.included_namespace_urls", namespace="inc-outer"),
),
re_path(
r"^\+\\\$\*/",
include("urlpatterns_reverse.namespace_urls", namespace="special"),
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/erroneous_urls.py | tests/urlpatterns_reverse/erroneous_urls.py | from django.urls import re_path
from . import views
urlpatterns = [
re_path(r"(regex_error/$", views.empty_view),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/views.py | tests/urlpatterns_reverse/views.py | from functools import partial, update_wrapper
from django.contrib.auth.decorators import user_passes_test
from django.http import HttpResponse
from django.urls import reverse_lazy
from django.views.generic import RedirectView, View
def empty_view(request, *args, **kwargs):
return HttpResponse()
def absolute_kwargs_view(request, arg1=1, arg2=2):
return HttpResponse()
def defaults_view(request, arg1, arg2):
pass
def nested_view(request):
pass
def erroneous_view(request):
import non_existent # NOQA
def pass_resolver_match_view(request, *args, **kwargs):
response = HttpResponse()
response.resolver_match = request.resolver_match
return response
uncallable = None # neither a callable nor a string
class ViewClass:
def __call__(self, request, *args, **kwargs):
return HttpResponse()
view_class_instance = ViewClass()
class LazyRedirectView(RedirectView):
url = reverse_lazy("named-lazy-url-redirected-to")
@user_passes_test(
lambda u: u.is_authenticated, login_url=reverse_lazy("some-login-page")
)
def login_required_view(request):
return HttpResponse("Hello you")
def bad_view(request, *args, **kwargs):
raise ValueError("I don't think I'm getting good value for this view")
class HelloView(View):
def get(self, request, *args, **kwargs):
return HttpResponse(f"Hello {self.kwargs['name']}")
view_func_from_cbv = HelloView.as_view()
empty_view_partial = partial(empty_view, template_name="template.html")
empty_view_nested_partial = partial(
empty_view_partial, template_name="nested_partial.html"
)
empty_view_wrapped = update_wrapper(
partial(empty_view, template_name="template.html"),
empty_view,
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/middleware.py | tests/urlpatterns_reverse/middleware.py | from django.http import HttpResponse, StreamingHttpResponse
from django.urls import reverse
from django.utils.deprecation import MiddlewareMixin
from . import urlconf_inner
class ChangeURLconfMiddleware(MiddlewareMixin):
def process_request(self, request):
request.urlconf = urlconf_inner.__name__
class NullChangeURLconfMiddleware(MiddlewareMixin):
def process_request(self, request):
request.urlconf = None
class ReverseInnerInResponseMiddleware(MiddlewareMixin):
def process_response(self, *args, **kwargs):
return HttpResponse(reverse("inner"))
class ReverseOuterInResponseMiddleware(MiddlewareMixin):
def process_response(self, *args, **kwargs):
return HttpResponse(reverse("outer"))
class ReverseInnerInStreaming(MiddlewareMixin):
def process_view(self, *args, **kwargs):
def stream():
yield reverse("inner")
return StreamingHttpResponse(stream())
class ReverseOuterInStreaming(MiddlewareMixin):
def process_view(self, *args, **kwargs):
def stream():
yield reverse("outer")
return StreamingHttpResponse(stream())
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_urls2.py | tests/urlpatterns_reverse/included_urls2.py | """
These URL patterns are included in two different ways in the main urls.py, with
an extra argument present in one case. Thus, there are two different ways for
each name to resolve and Django must distinguish the possibilities based on the
argument list.
"""
from django.urls import re_path
from .views import empty_view
urlpatterns = [
re_path(r"^part/(?P<value>\w+)/$", empty_view, name="part"),
re_path(r"^part2/(?:(?P<value>\w+)/)?$", empty_view, name="part2"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_app_urls.py | tests/urlpatterns_reverse/included_app_urls.py | from django.urls import path, re_path
from . import views
app_name = "inc-app"
urlpatterns = [
path("normal/", views.empty_view, name="inc-normal-view"),
re_path(
"^normal/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.empty_view,
name="inc-normal-view",
),
re_path(r"^\+\\\$\*/$", views.empty_view, name="inc-special-view"),
re_path(
"^mixed_args/([0-9]+)/(?P<arg2>[0-9]+)/$",
views.empty_view,
name="inc-mixed-args",
),
re_path("^no_kwargs/([0-9]+)/([0-9]+)/$", views.empty_view, name="inc-no-kwargs"),
re_path(
"^view_class/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.view_class_instance,
name="inc-view-class",
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/nested_urls.py | tests/urlpatterns_reverse/nested_urls.py | from django.urls import include, path
from django.views import View
def view1(request):
pass
def view2(request):
pass
class View3(View):
pass
nested = (
[
path("view1/", view1, name="view1"),
path("view3/", View3.as_view(), name="view3"),
],
"backend",
)
urlpatterns = [
path("some/path/", include(nested, namespace="nested")),
path("view2/", view2, name="view2"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_named_urls2.py | tests/urlpatterns_reverse/included_named_urls2.py | from django.urls import path, re_path
from .views import empty_view
urlpatterns = [
path("", empty_view, name="named-url5"),
re_path(r"^extra/(?P<extra>\w+)/$", empty_view, name="named-url6"),
re_path(r"^(?P<one>[0-9]+)|(?P<two>[0-9]+)/$", empty_view),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urlconf_inner.py | tests/urlpatterns_reverse/urlconf_inner.py | from django.http import HttpResponse
from django.template import Context, Template
from django.urls import path
def inner_view(request):
content = Template(
'{% url "outer" as outer_url %}outer:{{ outer_url }},'
'{% url "inner" as inner_url %}inner:{{ inner_url }}'
).render(Context())
return HttpResponse(content)
urlpatterns = [
path("second_test/", inner_view, name="inner"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/extra_urls.py | tests/urlpatterns_reverse/extra_urls.py | """
Some extra URL patterns that are included at the top level.
"""
from django.urls import include, path, re_path
from .views import empty_view
urlpatterns = [
re_path("^e-places/([0-9]+)/$", empty_view, name="extra-places"),
re_path(r"^e-people/(?P<name>\w+)/$", empty_view, name="extra-people"),
path("", include("urlpatterns_reverse.included_urls2")),
re_path(r"^prefix/(?P<prefix>\w+)/", include("urlpatterns_reverse.included_urls2")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/utils.py | tests/urlpatterns_reverse/utils.py | from django.urls import path, re_path
from . import views
class URLObject:
urlpatterns = [
path("inner/", views.empty_view, name="urlobject-view"),
re_path(
r"^inner/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
views.empty_view,
name="urlobject-view",
),
re_path(r"^inner/\+\\\$\*/$", views.empty_view, name="urlobject-special-view"),
]
def __init__(self, app_name, namespace=None):
self.app_name = app_name
self.namespace = namespace
@property
def urls(self):
return (self.urlpatterns, self.app_name), self.namespace
@property
def app_urls(self):
return self.urlpatterns, self.app_name
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/named_urls.py | tests/urlpatterns_reverse/named_urls.py | from django.urls import include, path, re_path
from .views import empty_view
urlpatterns = [
path("", empty_view, name="named-url1"),
re_path(r"^extra/(?P<extra>\w+)/$", empty_view, name="named-url2"),
re_path(r"^(?P<one>[0-9]+)|(?P<two>[0-9]+)/$", empty_view),
path("included/", include("urlpatterns_reverse.included_named_urls")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urls_without_handlers.py | tests/urlpatterns_reverse/urls_without_handlers.py | # A URLconf that doesn't define any handlerXXX.
from django.urls import path
from .views import bad_view, empty_view
urlpatterns = [
path("test_view/", empty_view, name="test_view"),
path("bad_view/", bad_view, name="bad_view"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_namespace_urls.py | tests/urlpatterns_reverse/included_namespace_urls.py | from django.urls import include, path, re_path
from .utils import URLObject
from .views import empty_view, view_class_instance
testobj3 = URLObject("testapp", "test-ns3")
testobj4 = URLObject("testapp", "test-ns4")
app_name = "included_namespace_urls"
urlpatterns = [
path("normal/", empty_view, name="inc-normal-view"),
re_path(
"^normal/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
empty_view,
name="inc-normal-view",
),
re_path(r"^\+\\\$\*/$", empty_view, name="inc-special-view"),
re_path(
"^mixed_args/([0-9]+)/(?P<arg2>[0-9]+)/$", empty_view, name="inc-mixed-args"
),
re_path("^no_kwargs/([0-9]+)/([0-9]+)/$", empty_view, name="inc-no-kwargs"),
re_path(
"^view_class/(?P<arg1>[0-9]+)/(?P<arg2>[0-9]+)/$",
view_class_instance,
name="inc-view-class",
),
path("test3/", include(*testobj3.urls)),
path("test4/", include(*testobj4.urls)),
path(
"ns-included3/",
include(
("urlpatterns_reverse.included_urls", "included_urls"), namespace="inc-ns3"
),
),
path(
"ns-included4/",
include("urlpatterns_reverse.namespace_urls", namespace="inc-ns4"),
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/reverse_lazy_urls.py | tests/urlpatterns_reverse/reverse_lazy_urls.py | from django.urls import path
from .views import LazyRedirectView, empty_view, login_required_view
urlpatterns = [
path("redirected_to/", empty_view, name="named-lazy-url-redirected-to"),
path("login/", empty_view, name="some-login-page"),
path("login_required_view/", login_required_view),
path("redirect/", LazyRedirectView.as_view()),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urlconf_outer.py | tests/urlpatterns_reverse/urlconf_outer.py | from django.urls import include, path
from . import urlconf_inner
urlpatterns = [
path("test/me/", urlconf_inner.inner_view, name="outer"),
path("inner_urlconf/", include(urlconf_inner.__name__)),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_urls.py | tests/urlpatterns_reverse/included_urls.py | from django.urls import path, re_path
from .views import empty_view
urlpatterns = [
path("", empty_view, name="inner-nothing"),
re_path(r"extra/(?P<extra>\w+)/$", empty_view, name="inner-extra"),
re_path(r"(?P<one>[0-9]+)|(?P<two>[0-9]+)/$", empty_view, name="inner-disjunction"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urls_error_handlers.py | tests/urlpatterns_reverse/urls_error_handlers.py | # Used by the ErrorHandlerResolutionTests test case.
urlpatterns = []
handler400 = "urlpatterns_reverse.views.empty_view"
handler403 = "urlpatterns_reverse.views.empty_view"
handler404 = "urlpatterns_reverse.views.empty_view"
handler500 = "urlpatterns_reverse.views.empty_view"
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/__init__.py | tests/urlpatterns_reverse/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/named_urls_conflict.py | tests/urlpatterns_reverse/named_urls_conflict.py | from django.urls import path, re_path
from .views import empty_view
urlpatterns = [
# No kwargs
path("conflict/cannot-go-here/", empty_view, name="name-conflict"),
path("conflict/", empty_view, name="name-conflict"),
# One kwarg
re_path(r"^conflict-first/(?P<first>\w+)/$", empty_view, name="name-conflict"),
re_path(
r"^conflict-cannot-go-here/(?P<middle>\w+)/$", empty_view, name="name-conflict"
),
re_path(r"^conflict-middle/(?P<middle>\w+)/$", empty_view, name="name-conflict"),
re_path(r"^conflict-last/(?P<last>\w+)/$", empty_view, name="name-conflict"),
# Two kwargs
re_path(
r"^conflict/(?P<another>\w+)/(?P<extra>\w+)/cannot-go-here/$",
empty_view,
name="name-conflict",
),
re_path(
r"^conflict/(?P<extra>\w+)/(?P<another>\w+)/$", empty_view, name="name-conflict"
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/tests.py | tests/urlpatterns_reverse/tests.py | """
Unit tests for reverse URL lookups.
"""
import pickle
import sys
import threading
from admin_scripts.tests import AdminScriptTestCase
from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ImproperlyConfigured, ViewDoesNotExist
from django.http import (
HttpRequest,
HttpResponsePermanentRedirect,
HttpResponseRedirect,
QueryDict,
)
from django.shortcuts import redirect
from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
from django.test.utils import override_script_prefix
from django.urls import (
NoReverseMatch,
Resolver404,
ResolverMatch,
URLPattern,
URLResolver,
get_callable,
get_resolver,
get_urlconf,
include,
path,
re_path,
resolve,
reverse,
reverse_lazy,
)
from django.urls.resolvers import RegexPattern
from . import middleware, urlconf_outer, views
from .utils import URLObject
from .views import empty_view
resolve_test_data = (
# These entries are in the format:
# (path, url_name, app_name, namespace, view_name, func, args, kwargs)
# Simple case
(
"/normal/42/37/",
"normal-view",
"",
"",
"normal-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/view_class/42/37/",
"view-class",
"",
"",
"view-class",
views.view_class_instance,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/included/normal/42/37/",
"inc-normal-view",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-normal-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/included/view_class/42/37/",
"inc-view-class",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-view-class",
views.view_class_instance,
(),
{"arg1": "42", "arg2": "37"},
),
# Unnamed args are dropped if you have *any* kwargs in a pattern
(
"/mixed_args/42/37/",
"mixed-args",
"",
"",
"mixed-args",
views.empty_view,
(),
{"extra": True, "arg2": "37"},
),
(
"/included/mixed_args/42/37/",
"inc-mixed-args",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-mixed-args",
views.empty_view,
(),
{"arg2": "37"},
),
(
"/included/12/mixed_args/42/37/",
"inc-mixed-args",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-mixed-args",
views.empty_view,
(),
{"arg2": "37"},
),
# Unnamed views should have None as the url_name. Regression data for
# #21157.
(
"/unnamed/normal/42/37/",
None,
"",
"",
"urlpatterns_reverse.views.empty_view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/unnamed/view_class/42/37/",
None,
"",
"",
"urlpatterns_reverse.views.ViewClass",
views.view_class_instance,
(),
{"arg1": "42", "arg2": "37"},
),
# If you have no kwargs, you get an args list.
(
"/no_kwargs/42/37/",
"no-kwargs",
"",
"",
"no-kwargs",
views.empty_view,
("42", "37"),
{},
),
(
"/included/no_kwargs/42/37/",
"inc-no-kwargs",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-no-kwargs",
views.empty_view,
("42", "37"),
{},
),
(
"/included/12/no_kwargs/42/37/",
"inc-no-kwargs",
"included_namespace_urls",
"included_namespace_urls",
"included_namespace_urls:inc-no-kwargs",
views.empty_view,
("12", "42", "37"),
{},
),
# Namespaces
(
"/test1/inner/42/37/",
"urlobject-view",
"testapp",
"test-ns1",
"test-ns1:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/included/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:testapp",
"included_namespace_urls:test-ns3",
"included_namespace_urls:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/ns-included1/normal/42/37/",
"inc-normal-view",
"included_namespace_urls",
"inc-ns1",
"inc-ns1:inc-normal-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/included/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:testapp",
"included_namespace_urls:test-ns3",
"included_namespace_urls:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/default/inner/42/37/",
"urlobject-view",
"testapp",
"testapp",
"testapp:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/other2/inner/42/37/",
"urlobject-view",
"nodefault",
"other-ns2",
"other-ns2:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/other1/inner/42/37/",
"urlobject-view",
"nodefault",
"other-ns1",
"other-ns1:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
# Nested namespaces
(
"/ns-included1/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:testapp",
"inc-ns1:test-ns3",
"inc-ns1:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/ns-included1/ns-included4/ns-included2/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:namespace_urls:included_namespace_urls:testapp",
"inc-ns1:inc-ns4:inc-ns2:test-ns3",
"inc-ns1:inc-ns4:inc-ns2:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/app-included/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:testapp",
"inc-app:test-ns3",
"inc-app:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
(
"/app-included/ns-included4/ns-included2/test3/inner/42/37/",
"urlobject-view",
"included_namespace_urls:namespace_urls:included_namespace_urls:testapp",
"inc-app:inc-ns4:inc-ns2:test-ns3",
"inc-app:inc-ns4:inc-ns2:test-ns3:urlobject-view",
views.empty_view,
(),
{"arg1": "42", "arg2": "37"},
),
# Namespaces capturing variables
(
"/inc70/",
"inner-nothing",
"included_urls",
"inc-ns5",
"inc-ns5:inner-nothing",
views.empty_view,
(),
{"outer": "70"},
),
(
"/inc78/extra/foobar/",
"inner-extra",
"included_urls",
"inc-ns5",
"inc-ns5:inner-extra",
views.empty_view,
(),
{"outer": "78", "extra": "foobar"},
),
)
test_data = (
("places", "/places/3/", [3], {}),
("places", "/places/3/", ["3"], {}),
("places", NoReverseMatch, ["a"], {}),
("places", NoReverseMatch, [], {}),
("places?", "/place/", [], {}),
("places+", "/places/", [], {}),
("places*", "/place/", [], {}),
("places2?", "/", [], {}),
("places2+", "/places/", [], {}),
("places2*", "/", [], {}),
("places3", "/places/4/", [4], {}),
("places3", "/places/harlem/", ["harlem"], {}),
("places3", NoReverseMatch, ["harlem64"], {}),
("places4", "/places/3/", [], {"id": 3}),
("people", NoReverseMatch, [], {}),
("people", "/people/adrian/", ["adrian"], {}),
("people", "/people/adrian/", [], {"name": "adrian"}),
("people", NoReverseMatch, ["name with spaces"], {}),
("people", NoReverseMatch, [], {"name": "name with spaces"}),
("people2", "/people/name/", [], {}),
("people2a", "/people/name/fred/", ["fred"], {}),
("people_backref", "/people/nate-nate/", ["nate"], {}),
("people_backref", "/people/nate-nate/", [], {"name": "nate"}),
("optional", "/optional/fred/", [], {"name": "fred"}),
("optional", "/optional/fred/", ["fred"], {}),
("named_optional", "/optional/1/", [1], {}),
("named_optional", "/optional/1/", [], {"arg1": 1}),
("named_optional", "/optional/1/2/", [1, 2], {}),
("named_optional", "/optional/1/2/", [], {"arg1": 1, "arg2": 2}),
("named_optional_terminated", "/optional/1/", [1], {}),
("named_optional_terminated", "/optional/1/", [], {"arg1": 1}),
("named_optional_terminated", "/optional/1/2/", [1, 2], {}),
("named_optional_terminated", "/optional/1/2/", [], {"arg1": 1, "arg2": 2}),
("hardcoded", "/hardcoded/", [], {}),
("hardcoded2", "/hardcoded/doc.pdf", [], {}),
("people3", "/people/il/adrian/", [], {"state": "il", "name": "adrian"}),
("people3", NoReverseMatch, [], {"state": "il"}),
("people3", NoReverseMatch, [], {"name": "adrian"}),
("people4", NoReverseMatch, [], {"state": "il", "name": "adrian"}),
("people6", "/people/il/test/adrian/", ["il/test", "adrian"], {}),
("people6", "/people//adrian/", ["adrian"], {}),
("range", "/character_set/a/", [], {}),
("range2", "/character_set/x/", [], {}),
("price", "/price/$10/", ["10"], {}),
("price2", "/price/$10/", ["10"], {}),
("price3", "/price/$10/", ["10"], {}),
(
"product",
"/product/chocolate+($2.00)/",
[],
{"price": "2.00", "product": "chocolate"},
),
("headlines", "/headlines/2007.5.21/", [], {"year": 2007, "month": 5, "day": 21}),
(
"windows",
r"/windows_path/C:%5CDocuments%20and%20Settings%5Cspam/",
[],
{"drive_name": "C", "path": r"Documents and Settings\spam"},
),
("special", r"/special_chars/~@+%5C$*%7C/", [r"~@+\$*|"], {}),
("special", r"/special_chars/some%20resource/", [r"some resource"], {}),
("special", r"/special_chars/10%25%20complete/", [r"10% complete"], {}),
("special", r"/special_chars/some%20resource/", [], {"chars": r"some resource"}),
("special", r"/special_chars/10%25%20complete/", [], {"chars": r"10% complete"}),
("special", NoReverseMatch, [""], {}),
("mixed", "/john/0/", [], {"name": "john"}),
("repeats", "/repeats/a/", [], {}),
("repeats2", "/repeats/aa/", [], {}),
("repeats3", "/repeats/aa/", [], {}),
("test", "/test/1", [], {}),
("inner-nothing", "/outer/42/", [], {"outer": "42"}),
("inner-nothing", "/outer/42/", ["42"], {}),
("inner-nothing", NoReverseMatch, ["foo"], {}),
("inner-extra", "/outer/42/extra/inner/", [], {"extra": "inner", "outer": "42"}),
("inner-extra", "/outer/42/extra/inner/", ["42", "inner"], {}),
("inner-extra", NoReverseMatch, ["fred", "inner"], {}),
("inner-no-kwargs", "/outer-no-kwargs/42/inner-no-kwargs/1/", ["42", "1"], {}),
("disjunction", NoReverseMatch, ["foo"], {}),
("inner-disjunction", NoReverseMatch, ["10", "11"], {}),
("extra-places", "/e-places/10/", ["10"], {}),
("extra-people", "/e-people/fred/", ["fred"], {}),
("extra-people", "/e-people/fred/", [], {"name": "fred"}),
("part", "/part/one/", [], {"value": "one"}),
("part", "/prefix/xx/part/one/", [], {"value": "one", "prefix": "xx"}),
("part2", "/part2/one/", [], {"value": "one"}),
("part2", "/part2/", [], {}),
("part2", "/prefix/xx/part2/one/", [], {"value": "one", "prefix": "xx"}),
("part2", "/prefix/xx/part2/", [], {"prefix": "xx"}),
# Tests for nested groups. Nested capturing groups will only work if you
# *only* supply the correct outer group.
("nested-noncapture", "/nested/noncapture/opt", [], {"p": "opt"}),
("nested-capture", "/nested/capture/opt/", ["opt/"], {}),
("nested-capture", NoReverseMatch, [], {"p": "opt"}),
("nested-mixedcapture", "/nested/capture/mixed/opt", ["opt"], {}),
("nested-mixedcapture", NoReverseMatch, [], {"p": "opt"}),
("nested-namedcapture", "/nested/capture/named/opt/", [], {"outer": "opt/"}),
("nested-namedcapture", NoReverseMatch, [], {"outer": "opt/", "inner": "opt"}),
("nested-namedcapture", NoReverseMatch, [], {"inner": "opt"}),
("non_path_include", "/includes/non_path_include/", [], {}),
# Tests for #13154
("defaults", "/defaults_view1/3/", [], {"arg1": 3, "arg2": 1}),
("defaults", "/defaults_view2/3/", [], {"arg1": 3, "arg2": 2}),
("defaults", NoReverseMatch, [], {"arg1": 3, "arg2": 3}),
("defaults", NoReverseMatch, [], {"arg2": 1}),
# Security tests
("security", "/%2Fexample.com/security/", ["/example.com"], {}),
)
@override_settings(ROOT_URLCONF="urlpatterns_reverse.no_urls")
class NoURLPatternsTests(SimpleTestCase):
def test_no_urls_exception(self):
"""
URLResolver should raise an exception when no urlpatterns exist.
"""
resolver = URLResolver(RegexPattern(r"^$"), settings.ROOT_URLCONF)
with self.assertRaisesMessage(
ImproperlyConfigured,
"The included URLconf 'urlpatterns_reverse.no_urls' does not "
"appear to have any patterns in it. If you see the 'urlpatterns' "
"variable with valid patterns in the file then the issue is "
"probably caused by a circular import.",
):
getattr(resolver, "url_patterns")
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls")
class URLPatternReverse(SimpleTestCase):
def test_urlpattern_reverse(self):
for name, expected, args, kwargs in test_data:
with self.subTest(name=name, args=args, kwargs=kwargs):
try:
got = reverse(name, args=args, kwargs=kwargs)
except NoReverseMatch:
self.assertEqual(NoReverseMatch, expected)
else:
self.assertEqual(got, expected)
def test_reverse_none(self):
# Reversing None should raise an error, not return the last un-named
# view.
with self.assertRaises(NoReverseMatch):
reverse(None)
def test_mixing_args_and_kwargs(self):
msg = "Don't mix *args and **kwargs in call to reverse()!"
with self.assertRaisesMessage(ValueError, msg):
reverse("name", args=["a"], kwargs={"b": "c"})
@override_script_prefix("/{{invalid}}/")
def test_prefix_braces(self):
self.assertEqual(
"/%7B%7Binvalid%7D%7D/includes/non_path_include/",
reverse("non_path_include"),
)
def test_prefix_parenthesis(self):
# Parentheses are allowed and should not cause errors or be escaped
with override_script_prefix("/bogus)/"):
self.assertEqual(
"/bogus)/includes/non_path_include/", reverse("non_path_include")
)
with override_script_prefix("/(bogus)/"):
self.assertEqual(
"/(bogus)/includes/non_path_include/", reverse("non_path_include")
)
@override_script_prefix("/bump%20map/")
def test_prefix_format_char(self):
self.assertEqual(
"/bump%2520map/includes/non_path_include/", reverse("non_path_include")
)
@override_script_prefix("/%7Eme/")
def test_non_urlsafe_prefix_with_args(self):
# Regression for #20022, adjusted for #24013 because ~ is an unreserved
# character. Tests whether % is escaped.
self.assertEqual("/%257Eme/places/1/", reverse("places", args=[1]))
def test_patterns_reported(self):
# Regression for #17076
with self.assertRaisesMessage(
NoReverseMatch, r"1 pattern(s) tried: ['people/(?P<name>\\w+)/$']"
):
# this url exists, but requires an argument
reverse("people", args=[])
@override_script_prefix("/script:name/")
def test_script_name_escaping(self):
self.assertEqual(
reverse("optional", args=["foo:bar"]), "/script:name/optional/foo:bar/"
)
def test_view_not_found_message(self):
msg = (
"Reverse for 'nonexistent-view' not found. 'nonexistent-view' "
"is not a valid view function or pattern name."
)
with self.assertRaisesMessage(NoReverseMatch, msg):
reverse("nonexistent-view")
def test_no_args_message(self):
msg = "Reverse for 'places' with no arguments not found. 1 pattern(s) tried:"
with self.assertRaisesMessage(NoReverseMatch, msg):
reverse("places")
def test_illegal_args_message(self):
msg = (
"Reverse for 'places' with arguments '(1, 2)' not found. 1 pattern(s) "
"tried:"
)
with self.assertRaisesMessage(NoReverseMatch, msg):
reverse("places", args=(1, 2))
def test_illegal_kwargs_message(self):
msg = (
"Reverse for 'places' with keyword arguments '{'arg1': 2}' not found. 1 "
"pattern(s) tried:"
)
with self.assertRaisesMessage(NoReverseMatch, msg):
reverse("places", kwargs={"arg1": 2})
def test_view_func_from_cbv(self):
expected = "/hello/world/"
url = reverse(views.view_func_from_cbv, kwargs={"name": "world"})
self.assertEqual(url, expected)
def test_view_func_from_cbv_no_expected_kwarg(self):
with self.assertRaises(NoReverseMatch):
reverse(views.view_func_from_cbv)
def test_reverse_with_query(self):
self.assertEqual(
reverse("test", query={"hello": "world", "foo": 123}),
"/test/1?hello=world&foo=123",
)
def test_reverse_with_query_sequences(self):
cases = [
[("hello", "world"), ("foo", 123), ("foo", 456)],
(("hello", "world"), ("foo", 123), ("foo", 456)),
{"hello": "world", "foo": (123, 456)},
]
for query in cases:
with self.subTest(query=query):
self.assertEqual(
reverse("test", query=query), "/test/1?hello=world&foo=123&foo=456"
)
def test_reverse_with_fragment(self):
self.assertEqual(reverse("test", fragment="tab-1"), "/test/1#tab-1")
def test_reverse_with_fragment_not_encoded(self):
self.assertEqual(
reverse("test", fragment="tab 1 is the best!"), "/test/1#tab 1 is the best!"
)
def test_reverse_with_query_and_fragment(self):
self.assertEqual(
reverse("test", query={"hello": "world", "foo": 123}, fragment="tab-1"),
"/test/1?hello=world&foo=123#tab-1",
)
def test_reverse_with_empty_fragment(self):
self.assertEqual(reverse("test", fragment=None), "/test/1")
self.assertEqual(reverse("test", fragment=""), "/test/1#")
def test_reverse_with_invalid_fragment(self):
cases = [0, False, {}, [], set(), ()]
for fragment in cases:
with self.subTest(fragment=fragment):
with self.assertRaises(TypeError):
reverse("test", fragment=fragment)
def test_reverse_with_empty_query(self):
cases = [None, "", {}, [], set(), (), QueryDict()]
for query in cases:
with self.subTest(query=query):
self.assertEqual(reverse("test", query=query), "/test/1")
def test_reverse_with_invalid_query(self):
cases = [0, False, [1, 3, 5], {1, 2, 3}]
for query in cases:
with self.subTest(query=query):
with self.assertRaises(TypeError):
print(reverse("test", query=query))
def test_reverse_encodes_query_string(self):
self.assertEqual(
reverse(
"test",
query={
"hello world": "django project",
"foo": [123, 456],
"@invalid": ["?", "!", "a b"],
},
),
"/test/1?hello+world=django+project&foo=123&foo=456"
"&%40invalid=%3F&%40invalid=%21&%40invalid=a+b",
)
def test_reverse_with_query_from_querydict(self):
query_string = "a=1&b=2&b=3&c=4"
query_dict = QueryDict(query_string)
self.assertEqual(reverse("test", query=query_dict), f"/test/1?{query_string}")
class ResolverTests(SimpleTestCase):
def test_resolver_repr(self):
"""
Test repr of URLResolver, especially when urlconf_name is a list
(#17892).
"""
# Pick a resolver from a namespaced URLconf
resolver = get_resolver("urlpatterns_reverse.namespace_urls")
sub_resolver = resolver.namespace_dict["test-ns1"][1]
self.assertIn("<URLPattern list>", repr(sub_resolver))
def test_reverse_lazy_object_coercion_by_resolve(self):
"""
Verifies lazy object returned by reverse_lazy is coerced to
text by resolve(). Previous to #21043, this would raise a TypeError.
"""
urls = "urlpatterns_reverse.named_urls"
proxy_url = reverse_lazy("named-url1", urlconf=urls)
resolver = get_resolver(urls)
resolver.resolve(proxy_url)
def test_resolver_reverse(self):
resolver = get_resolver("urlpatterns_reverse.named_urls")
test_urls = [
# (name, args, kwargs, expected)
("named-url1", (), {}, ""),
("named-url2", ("arg",), {}, "extra/arg/"),
("named-url2", (), {"extra": "arg"}, "extra/arg/"),
]
for name, args, kwargs, expected in test_urls:
with self.subTest(name=name, args=args, kwargs=kwargs):
self.assertEqual(resolver.reverse(name, *args, **kwargs), expected)
def test_resolver_reverse_conflict(self):
"""
URL pattern name arguments don't need to be unique. The last registered
pattern takes precedence for conflicting names.
"""
resolver = get_resolver("urlpatterns_reverse.named_urls_conflict")
test_urls = [
# (name, args, kwargs, expected)
# Without arguments, the last URL in urlpatterns has precedence.
("name-conflict", (), {}, "conflict/"),
# With an arg, the last URL in urlpatterns has precedence.
("name-conflict", ("arg",), {}, "conflict-last/arg/"),
# With a kwarg, other URL patterns can be reversed.
("name-conflict", (), {"first": "arg"}, "conflict-first/arg/"),
("name-conflict", (), {"middle": "arg"}, "conflict-middle/arg/"),
("name-conflict", (), {"last": "arg"}, "conflict-last/arg/"),
# The number and order of the arguments don't interfere with
# reversing.
("name-conflict", ("arg", "arg"), {}, "conflict/arg/arg/"),
]
for name, args, kwargs, expected in test_urls:
with self.subTest(name=name, args=args, kwargs=kwargs):
self.assertEqual(resolver.reverse(name, *args, **kwargs), expected)
def test_non_regex(self):
"""
A Resolver404 is raised if resolving doesn't meet the basic
requirements of a path to match - i.e., at the very least, it matches
the root pattern '^/'. Never return None from resolve() to prevent a
TypeError from occurring later (#10834).
"""
test_urls = ["", "a", "\\", "."]
for path_ in test_urls:
with self.subTest(path=path_):
with self.assertRaises(Resolver404):
resolve(path_)
def test_404_tried_urls_have_names(self):
"""
The list of URLs that come back from a Resolver404 exception contains
a list in the right format for printing out in the DEBUG 404 page with
both the patterns and URL names, if available.
"""
urls = "urlpatterns_reverse.named_urls"
# this list matches the expected URL types and names returned when
# you try to resolve a nonexistent URL in the first level of included
# URLs in named_urls.py (e.g., '/included/nonexistent-url')
url_types_names = [
[{"type": URLPattern, "name": "named-url1"}],
[{"type": URLPattern, "name": "named-url2"}],
[{"type": URLPattern, "name": None}],
[{"type": URLResolver}, {"type": URLPattern, "name": "named-url3"}],
[{"type": URLResolver}, {"type": URLPattern, "name": "named-url4"}],
[{"type": URLResolver}, {"type": URLPattern, "name": None}],
[{"type": URLResolver}, {"type": URLResolver}],
]
with self.assertRaisesMessage(Resolver404, "tried") as cm:
resolve("/included/nonexistent-url", urlconf=urls)
e = cm.exception
# make sure we at least matched the root ('/') url resolver:
self.assertIn("tried", e.args[0])
self.assertEqual(
len(e.args[0]["tried"]),
len(url_types_names),
"Wrong number of tried URLs returned. Expected %s, got %s."
% (len(url_types_names), len(e.args[0]["tried"])),
)
for tried, expected in zip(e.args[0]["tried"], url_types_names):
for t, e in zip(tried, expected):
with self.subTest(t):
self.assertIsInstance(
t, e["type"]
), "%s is not an instance of %s" % (t, e["type"])
if "name" in e:
if not e["name"]:
self.assertIsNone(
t.name, "Expected no URL name but found %s." % t.name
)
else:
self.assertEqual(
t.name,
e["name"],
'Wrong URL name. Expected "%s", got "%s".'
% (e["name"], t.name),
)
def test_namespaced_view_detail(self):
resolver = get_resolver("urlpatterns_reverse.nested_urls")
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.view1"))
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.view2"))
self.assertTrue(resolver._is_callback("urlpatterns_reverse.nested_urls.View3"))
self.assertFalse(resolver._is_callback("urlpatterns_reverse.nested_urls.blub"))
def test_view_detail_as_method(self):
# Views which have a class name as part of their path.
resolver = get_resolver("urlpatterns_reverse.method_view_urls")
self.assertTrue(
resolver._is_callback(
"urlpatterns_reverse.method_view_urls.ViewContainer.method_view"
)
)
self.assertTrue(
resolver._is_callback(
"urlpatterns_reverse.method_view_urls.ViewContainer.classmethod_view"
)
)
def test_populate_concurrency(self):
"""
URLResolver._populate() can be called concurrently, but not more
than once per thread (#26888).
"""
resolver = URLResolver(RegexPattern(r"^/"), "urlpatterns_reverse.urls")
resolver._local.populating = True
thread = threading.Thread(target=resolver._populate)
thread.start()
thread.join()
self.assertNotEqual(resolver._reverse_dict, {})
@override_settings(ROOT_URLCONF="urlpatterns_reverse.reverse_lazy_urls")
class ReverseLazyTest(TestCase):
def test_redirect_with_lazy_reverse(self):
response = self.client.get("/redirect/")
self.assertRedirects(response, "/redirected_to/", status_code=302)
def test_user_permission_with_lazy_reverse(self):
alfred = User.objects.create_user(
"alfred", "alfred@example.com", password="testpw"
)
response = self.client.get("/login_required_view/")
self.assertRedirects(
response, "/login/?next=/login_required_view/", status_code=302
)
self.client.force_login(alfred)
response = self.client.get("/login_required_view/")
self.assertEqual(response.status_code, 200)
def test_inserting_reverse_lazy_into_string(self):
self.assertEqual(
"Some URL: %s" % reverse_lazy("some-login-page"), "Some URL: /login/"
)
def test_build_absolute_uri(self):
factory = RequestFactory()
request = factory.get("/")
self.assertEqual(
request.build_absolute_uri(reverse_lazy("some-login-page")),
"http://testserver/login/",
)
class ReverseLazySettingsTest(AdminScriptTestCase):
"""
reverse_lazy can be used in settings without causing a circular
import error.
"""
def setUp(self):
super().setUp()
self.write_settings(
"settings.py",
extra=(
"from django.urls import reverse_lazy\n"
"LOGIN_URL = reverse_lazy('login')"
),
)
def test_lazy_in_settings(self):
out, err = self.run_manage(["check"])
self.assertNoOutput(err)
@override_settings(ROOT_URLCONF="urlpatterns_reverse.urls")
class ReverseShortcutTests(SimpleTestCase):
def test_redirect_to_object(self):
# We don't really need a model; just something with a get_absolute_url
class FakeObj:
def get_absolute_url(self):
return "/hi-there/"
res = redirect(FakeObj())
self.assertIsInstance(res, HttpResponseRedirect)
self.assertEqual(res.url, "/hi-there/")
res = redirect(FakeObj(), permanent=True)
self.assertIsInstance(res, HttpResponsePermanentRedirect)
self.assertEqual(res.url, "/hi-there/")
def test_redirect_to_view_name(self):
res = redirect("hardcoded2")
self.assertEqual(res.url, "/hardcoded/doc.pdf")
res = redirect("places", 1)
self.assertEqual(res.url, "/places/1/")
res = redirect("headlines", year="2008", month="02", day="17")
self.assertEqual(res.url, "/headlines/2008.02.17/")
with self.assertRaises(NoReverseMatch):
redirect("not-a-view")
def test_redirect_to_url(self):
res = redirect("/foo/")
self.assertEqual(res.url, "/foo/")
res = redirect("http://example.com/")
self.assertEqual(res.url, "http://example.com/")
# Assert that we can redirect using UTF-8 strings
res = redirect("/æøå/abc/")
self.assertEqual(res.url, "/%C3%A6%C3%B8%C3%A5/abc/")
# Assert that no imports are attempted when dealing with a relative
# path (previously, the below would resolve in a UnicodeEncodeError
# from __import__ )
res = redirect("/æøå.abc/")
self.assertEqual(res.url, "/%C3%A6%C3%B8%C3%A5.abc/")
res = redirect("os.path")
self.assertEqual(res.url, "os.path")
def test_no_illegal_imports(self):
# modules that are not listed in urlpatterns should not be importable
redirect("urlpatterns_reverse.nonimported_module.view")
self.assertNotIn("urlpatterns_reverse.nonimported_module", sys.modules)
def test_reverse_by_path_nested(self):
# Views added to urlpatterns using include() should be reversible.
from .views import nested_view
self.assertEqual(reverse(nested_view), "/includes/nested_path/")
def test_redirect_view_object(self):
from .views import absolute_kwargs_view
res = redirect(absolute_kwargs_view)
self.assertEqual(res.url, "/absolute_arg_view/")
with self.assertRaises(NoReverseMatch):
redirect(absolute_kwargs_view, wrong_argument=None)
@override_settings(ROOT_URLCONF="urlpatterns_reverse.namespace_urls")
class NamespaceTests(SimpleTestCase):
def test_ambiguous_object(self):
"""
Names deployed via dynamic URL objects that require namespaces can't
be resolved.
"""
test_urls = [
("urlobject-view", [], {}),
("urlobject-view", [37, 42], {}),
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/views_broken.py | tests/urlpatterns_reverse/views_broken.py | # I just raise an AttributeError to confuse the view loading mechanism
raise AttributeError("I am here to confuse django.urls.get_callable")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/test_localeregexdescriptor.py | tests/urlpatterns_reverse/test_localeregexdescriptor.py | import os
from pathlib import Path
from unittest import mock
from django.core.exceptions import ImproperlyConfigured
from django.test import SimpleTestCase, override_settings
from django.urls.resolvers import LocaleRegexDescriptor, RegexPattern
from django.utils import translation
here = os.path.dirname(os.path.abspath(__file__))
@override_settings(LOCALE_PATHS=[os.path.join(here, "translations", "locale")])
class LocaleRegexDescriptorTests(SimpleTestCase):
def setUp(self):
translation.trans_real._translations = {}
def tearDown(self):
translation.trans_real._translations = {}
def test_translated_regex_compiled_per_language(self):
provider = RegexPattern(translation.gettext_lazy("^foo/$"))
with translation.override("de"):
de_compiled = provider.regex
# compiled only once per language
error = AssertionError(
"tried to compile url regex twice for the same language"
)
with mock.patch("django.urls.resolvers.re.compile", side_effect=error):
de_compiled_2 = provider.regex
with translation.override("fr"):
fr_compiled = provider.regex
self.assertEqual(fr_compiled.pattern, "^foo-fr/$")
self.assertEqual(de_compiled.pattern, "^foo-de/$")
self.assertEqual(de_compiled, de_compiled_2)
def test_nontranslated_regex_compiled_once(self):
provider = RegexPattern("^foo/$")
with translation.override("de"):
de_compiled = provider.regex
with translation.override("fr"):
# compiled only once, regardless of language
error = AssertionError("tried to compile non-translated url regex twice")
with mock.patch("django.urls.resolvers.re.compile", side_effect=error):
fr_compiled = provider.regex
self.assertEqual(de_compiled.pattern, "^foo/$")
self.assertEqual(fr_compiled.pattern, "^foo/$")
def test_regex_compile_error(self):
"""Regex errors are re-raised as ImproperlyConfigured."""
provider = RegexPattern("*")
msg = '"*" is not a valid regular expression: nothing to repeat'
with self.assertRaisesMessage(ImproperlyConfigured, msg):
provider.regex
def test_access_locale_regex_descriptor(self):
self.assertIsInstance(RegexPattern.regex, LocaleRegexDescriptor)
@override_settings(LOCALE_PATHS=[Path(here) / "translations" / "locale"])
class LocaleRegexDescriptorPathLibTests(LocaleRegexDescriptorTests):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urls_error_handlers_callables.py | tests/urlpatterns_reverse/urls_error_handlers_callables.py | # Used by the ErrorHandlerResolutionTests test case.
from .views import empty_view
urlpatterns = []
handler400 = empty_view
handler403 = empty_view
handler404 = empty_view
handler500 = empty_view
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/included_no_kwargs_urls.py | tests/urlpatterns_reverse/included_no_kwargs_urls.py | from django.urls import re_path
from .views import empty_view
urlpatterns = [
re_path("^inner-no-kwargs/([0-9]+)/$", empty_view, name="inner-no-kwargs")
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/method_view_urls.py | tests/urlpatterns_reverse/method_view_urls.py | from django.urls import path
class ViewContainer:
def method_view(self, request):
pass
@classmethod
def classmethod_view(cls, request):
pass
view_container = ViewContainer()
urlpatterns = [
path("", view_container.method_view, name="instance-method-url"),
path("", ViewContainer.classmethod_view, name="instance-method-url"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/nonimported_module.py | tests/urlpatterns_reverse/nonimported_module.py | def view(request):
"""Stub view"""
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/urls.py | tests/urlpatterns_reverse/urls.py | from django.urls import include, path, re_path
from .views import (
absolute_kwargs_view,
defaults_view,
empty_view,
empty_view_nested_partial,
empty_view_partial,
empty_view_wrapped,
nested_view,
view_func_from_cbv,
)
other_patterns = [
path("non_path_include/", empty_view, name="non_path_include"),
path("nested_path/", nested_view),
]
urlpatterns = [
re_path(r"^places/([0-9]+)/$", empty_view, name="places"),
re_path(r"^places?/$", empty_view, name="places?"),
re_path(r"^places+/$", empty_view, name="places+"),
re_path(r"^places*/$", empty_view, name="places*"),
re_path(r"^(?:places/)?$", empty_view, name="places2?"),
re_path(r"^(?:places/)+$", empty_view, name="places2+"),
re_path(r"^(?:places/)*$", empty_view, name="places2*"),
re_path(r"^places/([0-9]+|[a-z_]+)/", empty_view, name="places3"),
re_path(r"^places/(?P<id>[0-9]+)/$", empty_view, name="places4"),
re_path(r"^people/(?P<name>\w+)/$", empty_view, name="people"),
re_path(r"^people/(?:name/)$", empty_view, name="people2"),
re_path(r"^people/(?:name/(\w+)/)?$", empty_view, name="people2a"),
re_path(r"^people/(?P<name>\w+)-(?P=name)/$", empty_view, name="people_backref"),
re_path(r"^optional/(?P<name>.*)/(?:.+/)?", empty_view, name="optional"),
re_path(
r"^optional/(?P<arg1>\d+)/(?:(?P<arg2>\d+)/)?",
absolute_kwargs_view,
name="named_optional",
),
re_path(
r"^optional/(?P<arg1>\d+)/(?:(?P<arg2>\d+)/)?$",
absolute_kwargs_view,
name="named_optional_terminated",
),
re_path(
r"^nested/noncapture/(?:(?P<p>\w+))$", empty_view, name="nested-noncapture"
),
re_path(r"^nested/capture/((\w+)/)?$", empty_view, name="nested-capture"),
re_path(
r"^nested/capture/mixed/((?P<p>\w+))$", empty_view, name="nested-mixedcapture"
),
re_path(
r"^nested/capture/named/(?P<outer>(?P<inner>\w+)/)?$",
empty_view,
name="nested-namedcapture",
),
re_path(r"^hardcoded/$", empty_view, name="hardcoded"),
re_path(r"^hardcoded/doc\.pdf$", empty_view, name="hardcoded2"),
re_path(r"^people/(?P<state>\w\w)/(?P<name>\w+)/$", empty_view, name="people3"),
re_path(r"^people/(?P<state>\w\w)/(?P<name>[0-9])/$", empty_view, name="people4"),
re_path(r"^people/((?P<state>\w\w)/test)?/(\w+)/$", empty_view, name="people6"),
re_path(r"^character_set/[abcdef0-9]/$", empty_view, name="range"),
re_path(r"^character_set/[\w]/$", empty_view, name="range2"),
re_path(r"^price/\$([0-9]+)/$", empty_view, name="price"),
re_path(r"^price/[$]([0-9]+)/$", empty_view, name="price2"),
re_path(r"^price/[\$]([0-9]+)/$", empty_view, name="price3"),
re_path(
r"^product/(?P<product>\w+)\+\(\$(?P<price>[0-9]+(\.[0-9]+)?)\)/$",
empty_view,
name="product",
),
re_path(
r"^headlines/(?P<year>[0-9]+)\.(?P<month>[0-9]+)\.(?P<day>[0-9]+)/$",
empty_view,
name="headlines",
),
re_path(
r"^windows_path/(?P<drive_name>[A-Z]):\\(?P<path>.+)/$",
empty_view,
name="windows",
),
re_path(r"^special_chars/(?P<chars>.+)/$", empty_view, name="special"),
re_path(r"^resolved/(?P<arg>\d+)/$", empty_view, {"extra": True}, name="resolved"),
re_path(
r"^resolved-overridden/(?P<arg>\d+)/(?P<overridden>\w+)/$",
empty_view,
{"extra": True, "overridden": "default"},
name="resolved-overridden",
),
re_path(r"^(?P<name>.+)/[0-9]+/$", empty_view, name="mixed"),
re_path(r"^repeats/a{1,2}/$", empty_view, name="repeats"),
re_path(r"^repeats/a{2,4}/$", empty_view, name="repeats2"),
re_path(r"^repeats/a{2}/$", empty_view, name="repeats3"),
re_path(r"^test/1/?", empty_view, name="test"),
re_path(r"^outer/(?P<outer>[0-9]+)/", include("urlpatterns_reverse.included_urls")),
re_path(
r"^outer-no-kwargs/([0-9]+)/",
include("urlpatterns_reverse.included_no_kwargs_urls"),
),
re_path("", include("urlpatterns_reverse.extra_urls")),
re_path(
r"^lookahead-/(?!not-a-city)(?P<city>[^/]+)/$",
empty_view,
name="lookahead-negative",
),
re_path(
r"^lookahead\+/(?=a-city)(?P<city>[^/]+)/$",
empty_view,
name="lookahead-positive",
),
re_path(
r"^lookbehind-/(?P<city>[^/]+)(?<!not-a-city)/$",
empty_view,
name="lookbehind-negative",
),
re_path(
r"^lookbehind\+/(?P<city>[^/]+)(?<=a-city)/$",
empty_view,
name="lookbehind-positive",
),
# Partials should be fine.
path("partial/", empty_view_partial, name="partial"),
path("partial_nested/", empty_view_nested_partial, name="partial_nested"),
path("partial_wrapped/", empty_view_wrapped, name="partial_wrapped"),
# This is non-reversible, but we shouldn't blow up when parsing it.
re_path(r"^(?:foo|bar)(\w+)/$", empty_view, name="disjunction"),
path("absolute_arg_view/", absolute_kwargs_view),
# Tests for #13154. Mixed syntax to test both ways of defining URLs.
re_path(
r"^defaults_view1/(?P<arg1>[0-9]+)/$",
defaults_view,
{"arg2": 1},
name="defaults",
),
re_path(
r"^defaults_view2/(?P<arg1>[0-9]+)/$", defaults_view, {"arg2": 2}, "defaults"
),
path("includes/", include(other_patterns)),
# Security tests
re_path("(.+)/security/$", empty_view, name="security"),
# View function from cbv.
path("hello/<slug:name>/", view_func_from_cbv),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/translations/__init__.py | tests/urlpatterns_reverse/translations/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/translations/locale/__init__.py | tests/urlpatterns_reverse/translations/locale/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/translations/locale/de/__init__.py | tests/urlpatterns_reverse/translations/locale/de/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/urlpatterns_reverse/translations/locale/fr/__init__.py | tests/urlpatterns_reverse/translations/locale/fr/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_formsets_regress/models.py | tests/model_formsets_regress/models.py | from django.db import models
class User(models.Model):
username = models.CharField(max_length=12, unique=True)
serial = models.IntegerField()
class UserSite(models.Model):
user = models.ForeignKey(User, models.CASCADE, to_field="username")
data = models.IntegerField()
class UserProfile(models.Model):
user = models.ForeignKey(User, models.CASCADE, unique=True, to_field="username")
about = models.TextField()
class UserPreferences(models.Model):
user = models.OneToOneField(
User,
models.CASCADE,
to_field="username",
primary_key=True,
)
favorite_number = models.IntegerField()
class ProfileNetwork(models.Model):
profile = models.ForeignKey(UserProfile, models.CASCADE, to_field="user")
network = models.IntegerField()
identifier = models.IntegerField()
class Place(models.Model):
name = models.CharField(max_length=50)
class Restaurant(Place):
pass
class Manager(models.Model):
restaurant = models.ForeignKey(Restaurant, models.CASCADE)
name = models.CharField(max_length=50)
class Network(models.Model):
name = models.CharField(max_length=15)
class Host(models.Model):
network = models.ForeignKey(Network, models.CASCADE)
hostname = models.CharField(max_length=25)
def __str__(self):
return self.hostname
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_formsets_regress/__init__.py | tests/model_formsets_regress/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/model_formsets_regress/tests.py | tests/model_formsets_regress/tests.py | from django import forms
from django.forms.formsets import DELETION_FIELD_NAME, BaseFormSet
from django.forms.models import (
BaseModelFormSet,
inlineformset_factory,
modelform_factory,
modelformset_factory,
)
from django.forms.utils import ErrorDict, ErrorList
from django.test import TestCase
from .models import (
Host,
Manager,
Network,
ProfileNetwork,
Restaurant,
User,
UserPreferences,
UserProfile,
UserSite,
)
class InlineFormsetTests(TestCase):
def test_formset_over_to_field(self):
"""
A formset over a ForeignKey with a to_field can be saved.
"""
Form = modelform_factory(User, fields="__all__")
FormSet = inlineformset_factory(User, UserSite, fields="__all__")
# Instantiate the Form and FormSet to prove
# you can create a form with no data
form = Form()
form_set = FormSet(instance=User())
# Now create a new User and UserSite instance
data = {
"serial": "1",
"username": "apollo13",
"usersite_set-TOTAL_FORMS": "1",
"usersite_set-INITIAL_FORMS": "0",
"usersite_set-MAX_NUM_FORMS": "0",
"usersite_set-0-data": "10",
"usersite_set-0-user": "apollo13",
}
user = User()
form = Form(data)
if form.is_valid():
user = form.save()
else:
self.fail("Errors found on form:%s" % form_set)
form_set = FormSet(data, instance=user)
if form_set.is_valid():
form_set.save()
usersite = UserSite.objects.values()
self.assertEqual(usersite[0]["data"], 10)
self.assertEqual(usersite[0]["user_id"], "apollo13")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
# Now update the UserSite instance
data = {
"usersite_set-TOTAL_FORMS": "1",
"usersite_set-INITIAL_FORMS": "1",
"usersite_set-MAX_NUM_FORMS": "0",
"usersite_set-0-id": str(usersite[0]["id"]),
"usersite_set-0-data": "11",
"usersite_set-0-user": "apollo13",
}
form_set = FormSet(data, instance=user)
if form_set.is_valid():
form_set.save()
usersite = UserSite.objects.values()
self.assertEqual(usersite[0]["data"], 11)
self.assertEqual(usersite[0]["user_id"], "apollo13")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
# Now add a new UserSite instance
data = {
"usersite_set-TOTAL_FORMS": "2",
"usersite_set-INITIAL_FORMS": "1",
"usersite_set-MAX_NUM_FORMS": "0",
"usersite_set-0-id": str(usersite[0]["id"]),
"usersite_set-0-data": "11",
"usersite_set-0-user": "apollo13",
"usersite_set-1-data": "42",
"usersite_set-1-user": "apollo13",
}
form_set = FormSet(data, instance=user)
if form_set.is_valid():
form_set.save()
usersite = UserSite.objects.values().order_by("data")
self.assertEqual(usersite[0]["data"], 11)
self.assertEqual(usersite[0]["user_id"], "apollo13")
self.assertEqual(usersite[1]["data"], 42)
self.assertEqual(usersite[1]["user_id"], "apollo13")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
def test_formset_over_inherited_model(self):
"""
A formset over a ForeignKey with a to_field can be saved.
"""
Form = modelform_factory(Restaurant, fields="__all__")
FormSet = inlineformset_factory(Restaurant, Manager, fields="__all__")
# Instantiate the Form and FormSet to prove
# you can create a form with no data
form = Form()
form_set = FormSet(instance=Restaurant())
# Now create a new Restaurant and Manager instance
data = {
"name": "Guido's House of Pasta",
"manager_set-TOTAL_FORMS": "1",
"manager_set-INITIAL_FORMS": "0",
"manager_set-MAX_NUM_FORMS": "0",
"manager_set-0-name": "Guido Van Rossum",
}
restaurant = User()
form = Form(data)
if form.is_valid():
restaurant = form.save()
else:
self.fail("Errors found on form:%s" % form_set)
form_set = FormSet(data, instance=restaurant)
if form_set.is_valid():
form_set.save()
manager = Manager.objects.values()
self.assertEqual(manager[0]["name"], "Guido Van Rossum")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
# Now update the Manager instance
data = {
"manager_set-TOTAL_FORMS": "1",
"manager_set-INITIAL_FORMS": "1",
"manager_set-MAX_NUM_FORMS": "0",
"manager_set-0-id": str(manager[0]["id"]),
"manager_set-0-name": "Terry Gilliam",
}
form_set = FormSet(data, instance=restaurant)
if form_set.is_valid():
form_set.save()
manager = Manager.objects.values()
self.assertEqual(manager[0]["name"], "Terry Gilliam")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
# Now add a new Manager instance
data = {
"manager_set-TOTAL_FORMS": "2",
"manager_set-INITIAL_FORMS": "1",
"manager_set-MAX_NUM_FORMS": "0",
"manager_set-0-id": str(manager[0]["id"]),
"manager_set-0-name": "Terry Gilliam",
"manager_set-1-name": "John Cleese",
}
form_set = FormSet(data, instance=restaurant)
if form_set.is_valid():
form_set.save()
manager = Manager.objects.values().order_by("name")
self.assertEqual(manager[0]["name"], "John Cleese")
self.assertEqual(manager[1]["name"], "Terry Gilliam")
else:
self.fail("Errors found on formset:%s" % form_set.errors)
def test_inline_model_with_to_field(self):
"""
#13794 --- An inline model with a to_field of a formset with instance
has working relations.
"""
FormSet = inlineformset_factory(User, UserSite, exclude=("is_superuser",))
user = User.objects.create(username="guido", serial=1337)
UserSite.objects.create(user=user, data=10)
formset = FormSet(instance=user)
# Testing the inline model's relation
self.assertEqual(formset[0].instance.user_id, "guido")
def test_inline_model_with_primary_to_field(self):
"""An inline model with a OneToOneField with to_field & primary key."""
FormSet = inlineformset_factory(
User, UserPreferences, exclude=("is_superuser",)
)
user = User.objects.create(username="guido", serial=1337)
UserPreferences.objects.create(user=user, favorite_number=10)
formset = FormSet(instance=user)
self.assertEqual(formset[0].fields["user"].initial, "guido")
def test_inline_model_with_to_field_to_rel(self):
"""
#13794 --- An inline model with a to_field to a related field of a
formset with instance has working relations.
"""
FormSet = inlineformset_factory(UserProfile, ProfileNetwork, exclude=[])
user = User.objects.create(username="guido", serial=1337, pk=1)
self.assertEqual(user.pk, 1)
profile = UserProfile.objects.create(user=user, about="about", pk=2)
self.assertEqual(profile.pk, 2)
ProfileNetwork.objects.create(profile=profile, network=10, identifier=10)
formset = FormSet(instance=profile)
# Testing the inline model's relation
self.assertEqual(formset[0].instance.profile_id, 1)
def test_formset_with_none_instance(self):
"A formset with instance=None can be created. Regression for #11872"
Form = modelform_factory(User, fields="__all__")
FormSet = inlineformset_factory(User, UserSite, fields="__all__")
# Instantiate the Form and FormSet to prove
# you can create a formset with an instance of None
Form(instance=None)
FormSet(instance=None)
def test_empty_fields_on_modelformset(self):
"""
No fields passed to modelformset_factory() should result in no fields
on returned forms except for the id (#14119).
"""
UserFormSet = modelformset_factory(User, fields=())
formset = UserFormSet()
for form in formset.forms:
self.assertIn("id", form.fields)
self.assertEqual(len(form.fields), 1)
def test_save_as_new_with_new_inlines(self):
"""
Existing and new inlines are saved with save_as_new.
Regression for #14938.
"""
efnet = Network.objects.create(name="EFNet")
host1 = Host.objects.create(hostname="irc.he.net", network=efnet)
HostFormSet = inlineformset_factory(Network, Host, fields="__all__")
# Add a new host, modify previous host, and save-as-new
data = {
"host_set-TOTAL_FORMS": "2",
"host_set-INITIAL_FORMS": "1",
"host_set-MAX_NUM_FORMS": "0",
"host_set-0-id": str(host1.id),
"host_set-0-hostname": "tranquility.hub.dal.net",
"host_set-1-hostname": "matrix.de.eu.dal.net",
}
# To save a formset as new, it needs a new hub instance
dalnet = Network.objects.create(name="DALnet")
formset = HostFormSet(data, instance=dalnet, save_as_new=True)
self.assertTrue(formset.is_valid())
formset.save()
self.assertQuerySetEqual(
dalnet.host_set.order_by("hostname"),
Host.objects.filter(
hostname__in=[
"matrix.de.eu.dal.net",
"tranquility.hub.dal.net",
]
).order_by("hostname"),
)
def test_initial_data(self):
user = User.objects.create(username="bibi", serial=1)
UserSite.objects.create(user=user, data=7)
FormSet = inlineformset_factory(User, UserSite, extra=2, fields="__all__")
formset = FormSet(instance=user, initial=[{"data": 41}, {"data": 42}])
self.assertEqual(formset.forms[0].initial["data"], 7)
self.assertEqual(formset.extra_forms[0].initial["data"], 41)
self.assertIn('value="42"', formset.extra_forms[1].as_p())
class FormsetTests(TestCase):
def test_error_class(self):
"""
Test the type of Formset and Form error attributes
"""
Formset = modelformset_factory(User, fields="__all__")
data = {
"form-TOTAL_FORMS": "2",
"form-INITIAL_FORMS": "0",
"form-MAX_NUM_FORMS": "0",
"form-0-id": "",
"form-0-username": "apollo13",
"form-0-serial": "1",
"form-1-id": "",
"form-1-username": "apollo13",
"form-1-serial": "2",
}
formset = Formset(data)
# check if the returned error classes are correct
# note: formset.errors returns a list as documented
self.assertIsInstance(formset.errors, list)
self.assertIsInstance(formset.non_form_errors(), ErrorList)
for form in formset.forms:
self.assertIsInstance(form.errors, ErrorDict)
self.assertIsInstance(form.non_field_errors(), ErrorList)
def test_initial_data(self):
User.objects.create(username="bibi", serial=1)
Formset = modelformset_factory(User, fields="__all__", extra=2)
formset = Formset(initial=[{"username": "apollo11"}, {"username": "apollo12"}])
self.assertEqual(formset.forms[0].initial["username"], "bibi")
self.assertEqual(formset.extra_forms[0].initial["username"], "apollo11")
self.assertIn('value="apollo12"', formset.extra_forms[1].as_p())
def test_extraneous_query_is_not_run(self):
Formset = modelformset_factory(Network, fields="__all__")
data = {
"test-TOTAL_FORMS": "1",
"test-INITIAL_FORMS": "0",
"test-MAX_NUM_FORMS": "",
"test-0-name": "Random Place",
}
with self.assertNumQueries(1):
formset = Formset(data, prefix="test")
formset.save()
class CustomWidget(forms.widgets.TextInput):
pass
class UserSiteForm(forms.ModelForm):
class Meta:
model = UserSite
fields = "__all__"
widgets = {
"id": CustomWidget,
"data": CustomWidget,
}
localized_fields = ("data",)
class Callback:
def __init__(self):
self.log = []
def __call__(self, db_field, **kwargs):
self.log.append((db_field, kwargs))
return db_field.formfield(**kwargs)
class FormfieldCallbackTests(TestCase):
"""
Regression for #13095 and #17683: Using base forms with widgets
defined in Meta should not raise errors and BaseModelForm should respect
the specified pk widget.
"""
def test_inlineformset_factory_default(self):
Formset = inlineformset_factory(
User, UserSite, form=UserSiteForm, fields="__all__"
)
form = Formset().forms[0]
self.assertIsInstance(form["id"].field.widget, CustomWidget)
self.assertIsInstance(form["data"].field.widget, CustomWidget)
self.assertFalse(form.fields["id"].localize)
self.assertTrue(form.fields["data"].localize)
def test_modelformset_factory_default(self):
Formset = modelformset_factory(UserSite, form=UserSiteForm)
form = Formset().forms[0]
self.assertIsInstance(form["id"].field.widget, CustomWidget)
self.assertIsInstance(form["data"].field.widget, CustomWidget)
self.assertFalse(form.fields["id"].localize)
self.assertTrue(form.fields["data"].localize)
def assertCallbackCalled(self, callback):
id_field, user_field, data_field = UserSite._meta.fields
expected_log = [
(id_field, {"widget": CustomWidget}),
(user_field, {}),
(data_field, {"widget": CustomWidget, "localize": True}),
]
self.assertEqual(callback.log, expected_log)
def test_inlineformset_custom_callback(self):
callback = Callback()
inlineformset_factory(
User,
UserSite,
form=UserSiteForm,
formfield_callback=callback,
fields="__all__",
)
self.assertCallbackCalled(callback)
def test_modelformset_custom_callback(self):
callback = Callback()
modelformset_factory(UserSite, form=UserSiteForm, formfield_callback=callback)
self.assertCallbackCalled(callback)
class BaseCustomDeleteFormSet(BaseFormSet):
"""
A formset mix-in that lets a form decide if it's to be deleted.
Works for BaseFormSets. Also works for ModelFormSets with #14099 fixed.
form.should_delete() is called. The formset delete field is also
suppressed.
"""
def add_fields(self, form, index):
super().add_fields(form, index)
self.can_delete = True
if DELETION_FIELD_NAME in form.fields:
del form.fields[DELETION_FIELD_NAME]
def _should_delete_form(self, form):
return hasattr(form, "should_delete") and form.should_delete()
class FormfieldShouldDeleteFormTests(TestCase):
"""
BaseModelFormSet should use ModelFormSet method _should_delete_form.
"""
class BaseCustomDeleteModelFormSet(BaseModelFormSet, BaseCustomDeleteFormSet):
"""Model FormSet with CustomDelete MixIn"""
class CustomDeleteUserForm(forms.ModelForm):
"""A model form with a 'should_delete' method"""
class Meta:
model = User
fields = "__all__"
def should_delete(self):
"""Delete form if odd serial."""
return self.instance.serial % 2 != 0
NormalFormset = modelformset_factory(
User, form=CustomDeleteUserForm, can_delete=True
)
DeleteFormset = modelformset_factory(
User, form=CustomDeleteUserForm, formset=BaseCustomDeleteModelFormSet
)
data = {
"form-TOTAL_FORMS": "4",
"form-INITIAL_FORMS": "0",
"form-MAX_NUM_FORMS": "4",
"form-0-username": "John",
"form-0-serial": "1",
"form-1-username": "Paul",
"form-1-serial": "2",
"form-2-username": "George",
"form-2-serial": "3",
"form-3-username": "Ringo",
"form-3-serial": "5",
}
delete_all_ids = {
"form-0-DELETE": "1",
"form-1-DELETE": "1",
"form-2-DELETE": "1",
"form-3-DELETE": "1",
}
def test_init_database(self):
"""Add test data to database via formset"""
formset = self.NormalFormset(self.data)
self.assertTrue(formset.is_valid())
self.assertEqual(len(formset.save()), 4)
def test_no_delete(self):
"""Verify base formset doesn't modify database"""
# reload database
self.test_init_database()
# pass standard data dict & see none updated
data = dict(self.data)
data["form-INITIAL_FORMS"] = 4
data.update(
{
"form-%d-id" % i: user.pk
for i, user in enumerate(User.objects.order_by("pk"))
}
)
formset = self.NormalFormset(data, queryset=User.objects.all())
self.assertTrue(formset.is_valid())
self.assertEqual(len(formset.save()), 0)
self.assertEqual(len(User.objects.all()), 4)
def test_all_delete(self):
"""Verify base formset honors DELETE field"""
# reload database
self.test_init_database()
# create data dict with all fields marked for deletion
data = dict(self.data)
data["form-INITIAL_FORMS"] = 4
data.update(
{"form-%d-id" % i: user.pk for i, user in enumerate(User.objects.all())}
)
data.update(self.delete_all_ids)
formset = self.NormalFormset(data, queryset=User.objects.all())
self.assertTrue(formset.is_valid())
self.assertEqual(len(formset.save()), 0)
self.assertEqual(len(User.objects.all()), 0)
def test_custom_delete(self):
"""Verify DeleteFormset ignores DELETE field and uses form method"""
# reload database
self.test_init_database()
# Create formset with custom Delete function
# create data dict with all fields marked for deletion
data = dict(self.data)
data["form-INITIAL_FORMS"] = 4
data.update(
{
"form-%d-id" % i: user.pk
for i, user in enumerate(User.objects.order_by("pk"))
}
)
data.update(self.delete_all_ids)
formset = self.DeleteFormset(data, queryset=User.objects.all())
# Three with odd serial values were deleted.
self.assertTrue(formset.is_valid())
self.assertEqual(len(formset.save()), 0)
self.assertEqual(User.objects.count(), 1)
# No odd serial values left.
odd_serials = [user.serial for user in User.objects.all() if user.serial % 2]
self.assertEqual(len(odd_serials), 0)
class RedeleteTests(TestCase):
def test_resubmit(self):
u = User.objects.create(username="foo", serial=1)
us = UserSite.objects.create(user=u, data=7)
formset_cls = inlineformset_factory(User, UserSite, fields="__all__")
data = {
"serial": "1",
"username": "foo",
"usersite_set-TOTAL_FORMS": "1",
"usersite_set-INITIAL_FORMS": "1",
"usersite_set-MAX_NUM_FORMS": "1",
"usersite_set-0-id": str(us.pk),
"usersite_set-0-data": "7",
"usersite_set-0-user": "foo",
"usersite_set-0-DELETE": "1",
}
formset = formset_cls(data, instance=u)
self.assertTrue(formset.is_valid())
formset.save()
self.assertEqual(UserSite.objects.count(), 0)
formset = formset_cls(data, instance=u)
# Even if the "us" object isn't in the DB any more, the form
# validates.
self.assertTrue(formset.is_valid())
formset.save()
self.assertEqual(UserSite.objects.count(), 0)
def test_delete_already_deleted(self):
u = User.objects.create(username="foo", serial=1)
us = UserSite.objects.create(user=u, data=7)
formset_cls = inlineformset_factory(User, UserSite, fields="__all__")
data = {
"serial": "1",
"username": "foo",
"usersite_set-TOTAL_FORMS": "1",
"usersite_set-INITIAL_FORMS": "1",
"usersite_set-MAX_NUM_FORMS": "1",
"usersite_set-0-id": str(us.pk),
"usersite_set-0-data": "7",
"usersite_set-0-user": "foo",
"usersite_set-0-DELETE": "1",
}
formset = formset_cls(data, instance=u)
us.delete()
self.assertTrue(formset.is_valid())
formset.save()
self.assertEqual(UserSite.objects.count(), 0)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/select_related_regress/models.py | tests/select_related_regress/models.py | from django.db import models
class Building(models.Model):
name = models.CharField(max_length=10)
class Device(models.Model):
building = models.ForeignKey("Building", models.CASCADE)
name = models.CharField(max_length=10)
class Port(models.Model):
device = models.ForeignKey("Device", models.CASCADE)
port_number = models.CharField(max_length=10)
def __str__(self):
return "%s/%s" % (self.device.name, self.port_number)
class Connection(models.Model):
start = models.ForeignKey(
Port,
models.CASCADE,
related_name="connection_start",
unique=True,
)
end = models.ForeignKey(
Port,
models.CASCADE,
related_name="connection_end",
unique=True,
)
# Another non-tree hierarchy that exercises code paths similar to the above
# example, but in a slightly different configuration.
class TUser(models.Model):
name = models.CharField(max_length=200)
class Person(models.Model):
user = models.ForeignKey(TUser, models.CASCADE, unique=True)
class Organizer(models.Model):
person = models.ForeignKey(Person, models.CASCADE)
class Student(models.Model):
person = models.ForeignKey(Person, models.CASCADE)
class Class(models.Model):
org = models.ForeignKey(Organizer, models.CASCADE)
class Enrollment(models.Model):
std = models.ForeignKey(Student, models.CASCADE)
cls = models.ForeignKey(Class, models.CASCADE)
# Models for testing bug #8036.
class Country(models.Model):
name = models.CharField(max_length=50)
class State(models.Model):
name = models.CharField(max_length=50)
country = models.ForeignKey(Country, models.CASCADE)
class ClientStatus(models.Model):
name = models.CharField(max_length=50)
class Client(models.Model):
name = models.CharField(max_length=50)
state = models.ForeignKey(State, models.SET_NULL, null=True)
status = models.ForeignKey(ClientStatus, models.CASCADE)
class SpecialClient(Client):
value = models.IntegerField()
# Some model inheritance exercises
class Parent(models.Model):
name = models.CharField(max_length=10)
class Child(Parent):
value = models.IntegerField()
class Item(models.Model):
name = models.CharField(max_length=10)
child = models.ForeignKey(Child, models.SET_NULL, null=True)
def __str__(self):
return self.name
# Models for testing bug #19870.
class Fowl(models.Model):
name = models.CharField(max_length=10)
class Hen(Fowl):
pass
class Chick(Fowl):
mother = models.ForeignKey(Hen, models.CASCADE)
class Base(models.Model):
name = models.CharField(max_length=10)
lots_of_text = models.TextField()
class Meta:
abstract = True
class A(Base):
a_field = models.CharField(max_length=10)
class B(Base):
b_field = models.CharField(max_length=10)
class C(Base):
c_a = models.ForeignKey(A, models.CASCADE)
c_b = models.ForeignKey(B, models.CASCADE)
is_published = models.BooleanField(default=False)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/select_related_regress/__init__.py | tests/select_related_regress/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/select_related_regress/tests.py | tests/select_related_regress/tests.py | from django.test import TestCase
from .models import (
A,
B,
Building,
C,
Chick,
Child,
Class,
Client,
ClientStatus,
Connection,
Country,
Device,
Enrollment,
Hen,
Item,
Organizer,
Person,
Port,
SpecialClient,
State,
Student,
TUser,
)
class SelectRelatedRegressTests(TestCase):
def test_regression_7110(self):
"""
Regression test for bug #7110.
When using select_related(), we must query the
Device and Building tables using two different aliases (each) in order
to differentiate the start and end Connection fields. The net result is
that both the "connections = ..." queries here should give the same
results without pulling in more than the absolute minimum number of
tables (history has shown that it's easy to make a mistake in the
implementation and include some unnecessary bonus joins).
"""
b = Building.objects.create(name="101")
dev1 = Device.objects.create(name="router", building=b)
dev2 = Device.objects.create(name="switch", building=b)
dev3 = Device.objects.create(name="server", building=b)
port1 = Port.objects.create(port_number="4", device=dev1)
port2 = Port.objects.create(port_number="7", device=dev2)
port3 = Port.objects.create(port_number="1", device=dev3)
c1 = Connection.objects.create(start=port1, end=port2)
c2 = Connection.objects.create(start=port2, end=port3)
connections = Connection.objects.filter(
start__device__building=b, end__device__building=b
).order_by("id")
self.assertEqual(
[(c.id, str(c.start), str(c.end)) for c in connections],
[(c1.id, "router/4", "switch/7"), (c2.id, "switch/7", "server/1")],
)
connections = (
Connection.objects.filter(
start__device__building=b, end__device__building=b
)
.select_related()
.order_by("id")
)
self.assertEqual(
[(c.id, str(c.start), str(c.end)) for c in connections],
[(c1.id, "router/4", "switch/7"), (c2.id, "switch/7", "server/1")],
)
# This final query should only have seven tables (port, device and
# building twice each, plus connection once). Thus, 6 joins plus the
# FROM table.
self.assertEqual(str(connections.query).count(" JOIN "), 6)
def test_regression_8106(self):
"""
Regression test for bug #8106.
Same sort of problem as the previous test, but this time there are
more extra tables to pull in as part of the select_related() and some
of them could potentially clash (so need to be kept separate).
"""
us = TUser.objects.create(name="std")
usp = Person.objects.create(user=us)
uo = TUser.objects.create(name="org")
uop = Person.objects.create(user=uo)
s = Student.objects.create(person=usp)
o = Organizer.objects.create(person=uop)
c = Class.objects.create(org=o)
Enrollment.objects.create(std=s, cls=c)
e_related = Enrollment.objects.select_related()[0]
self.assertEqual(e_related.std.person.user.name, "std")
self.assertEqual(e_related.cls.org.person.user.name, "org")
def test_regression_8036(self):
"""
Regression test for bug #8036
the first related model in the tests below
("state") is empty and we try to select the more remotely related
state__country. The regression here was not skipping the empty column
results for country before getting status.
"""
Country.objects.create(name="Australia")
active = ClientStatus.objects.create(name="active")
client = Client.objects.create(name="client", status=active)
self.assertEqual(client.status, active)
self.assertEqual(Client.objects.select_related()[0].status, active)
self.assertEqual(Client.objects.select_related("state")[0].status, active)
self.assertEqual(
Client.objects.select_related("state", "status")[0].status, active
)
self.assertEqual(
Client.objects.select_related("state__country")[0].status, active
)
self.assertEqual(
Client.objects.select_related("state__country", "status")[0].status, active
)
self.assertEqual(Client.objects.select_related("status")[0].status, active)
def test_multi_table_inheritance(self):
"""Exercising select_related() with multi-table model inheritance."""
c1 = Child.objects.create(name="child1", value=42)
i1 = Item.objects.create(name="item1", child=c1)
i2 = Item.objects.create(name="item2")
self.assertSequenceEqual(
Item.objects.select_related("child").order_by("name"),
[i1, i2],
)
def test_regression_12851(self):
"""
Regression for #12851
Deferred fields are used correctly if you select_related a subset
of fields.
"""
australia = Country.objects.create(name="Australia")
active = ClientStatus.objects.create(name="active")
wa = State.objects.create(name="Western Australia", country=australia)
Client.objects.create(name="Brian Burke", state=wa, status=active)
burke = (
Client.objects.select_related("state")
.defer("state__name")
.get(name="Brian Burke")
)
self.assertEqual(burke.name, "Brian Burke")
self.assertEqual(burke.state.name, "Western Australia")
# Still works if we're dealing with an inherited class
SpecialClient.objects.create(
name="Troy Buswell", state=wa, status=active, value=42
)
troy = (
SpecialClient.objects.select_related("state")
.defer("state__name")
.get(name="Troy Buswell")
)
self.assertEqual(troy.name, "Troy Buswell")
self.assertEqual(troy.value, 42)
self.assertEqual(troy.state.name, "Western Australia")
# Still works if we defer an attribute on the inherited class
troy = (
SpecialClient.objects.select_related("state")
.defer("value", "state__name")
.get(name="Troy Buswell")
)
self.assertEqual(troy.name, "Troy Buswell")
self.assertEqual(troy.value, 42)
self.assertEqual(troy.state.name, "Western Australia")
# Also works if you use only, rather than defer
troy = (
SpecialClient.objects.select_related("state")
.only("name", "state")
.get(name="Troy Buswell")
)
self.assertEqual(troy.name, "Troy Buswell")
self.assertEqual(troy.value, 42)
self.assertEqual(troy.state.name, "Western Australia")
def test_null_join_promotion(self):
australia = Country.objects.create(name="Australia")
active = ClientStatus.objects.create(name="active")
wa = State.objects.create(name="Western Australia", country=australia)
bob = Client.objects.create(name="Bob", status=active)
jack = Client.objects.create(name="Jack", status=active, state=wa)
qs = Client.objects.filter(state=wa).select_related("state")
with self.assertNumQueries(1):
self.assertEqual(list(qs), [jack])
self.assertEqual(qs[0].state, wa)
# The select_related join wasn't promoted as there was already an
# existing (even if trimmed) inner join to state.
self.assertNotIn("LEFT OUTER", str(qs.query))
qs = Client.objects.select_related("state").order_by("name")
with self.assertNumQueries(1):
self.assertEqual(list(qs), [bob, jack])
self.assertIs(qs[0].state, None)
self.assertEqual(qs[1].state, wa)
# The select_related join was promoted as there is already an
# existing join.
self.assertIn("LEFT OUTER", str(qs.query))
def test_regression_19870(self):
hen = Hen.objects.create(name="Hen")
Chick.objects.create(name="Chick", mother=hen)
self.assertEqual(Chick.objects.all()[0].mother.name, "Hen")
self.assertEqual(Chick.objects.select_related()[0].mother.name, "Hen")
def test_regression_10733(self):
a = A.objects.create(name="a", lots_of_text="lots_of_text_a", a_field="a_field")
b = B.objects.create(name="b", lots_of_text="lots_of_text_b", b_field="b_field")
c = C.objects.create(
name="c", lots_of_text="lots_of_text_c", is_published=True, c_a=a, c_b=b
)
results = C.objects.only(
"name",
"lots_of_text",
"c_a",
"c_b",
"c_b__lots_of_text",
"c_a__name",
"c_b__name",
).select_related()
self.assertSequenceEqual(results, [c])
with self.assertNumQueries(0):
qs_c = results[0]
self.assertEqual(qs_c.name, "c")
self.assertEqual(qs_c.lots_of_text, "lots_of_text_c")
self.assertEqual(qs_c.c_b.lots_of_text, "lots_of_text_b")
self.assertEqual(qs_c.c_a.name, "a")
self.assertEqual(qs_c.c_b.name, "b")
def test_regression_22508(self):
building = Building.objects.create(name="101")
device = Device.objects.create(name="router", building=building)
Port.objects.create(port_number="1", device=device)
device = Device.objects.get()
port = device.port_set.select_related("device__building").get()
with self.assertNumQueries(0):
port.device.building
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_models.py | tests/invalid_models_tests/test_models.py | import unittest
from django.core.checks import Error, Warning
from django.core.checks.model_checks import _check_lazy_references
from django.db import connection, connections, models
from django.db.models.functions import Abs, Lower, Round
from django.db.models.signals import post_init
from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
from django.test.utils import isolate_apps, override_settings, register_lookup
class EmptyRouter:
pass
def get_max_column_name_length():
allowed_len = None
db_alias = None
for db in ("default", "other"):
connection = connections[db]
max_name_length = connection.ops.max_name_length()
if max_name_length is not None and not connection.features.truncates_names:
if allowed_len is None or max_name_length < allowed_len:
allowed_len = max_name_length
db_alias = db
return (allowed_len, db_alias)
@isolate_apps("invalid_models_tests")
class UniqueTogetherTests(SimpleTestCase):
def test_non_iterable(self):
class Model(models.Model):
class Meta:
unique_together = 42
self.assertEqual(
Model.check(),
[
Error(
"'unique_together' must be a list or tuple.",
obj=Model,
id="models.E010",
),
],
)
def test_list_containing_non_iterable(self):
class Model(models.Model):
one = models.IntegerField()
two = models.IntegerField()
class Meta:
unique_together = [("a", "b"), 42]
self.assertEqual(
Model.check(),
[
Error(
"All 'unique_together' elements must be lists or tuples.",
obj=Model,
id="models.E011",
),
],
)
def test_non_list(self):
class Model(models.Model):
class Meta:
unique_together = "not-a-list"
self.assertEqual(
Model.check(),
[
Error(
"'unique_together' must be a list or tuple.",
obj=Model,
id="models.E010",
),
],
)
def test_valid_model(self):
class Model(models.Model):
one = models.IntegerField()
two = models.IntegerField()
class Meta:
# unique_together can be a simple tuple
unique_together = ("one", "two")
self.assertEqual(Model.check(), [])
def test_pointing_to_missing_field(self):
class Model(models.Model):
class Meta:
unique_together = [["missing_field"]]
self.assertEqual(
Model.check(),
[
Error(
"'unique_together' refers to the nonexistent field "
"'missing_field'.",
obj=Model,
id="models.E012",
),
],
)
def test_pointing_to_m2m(self):
class Model(models.Model):
m2m = models.ManyToManyField("self")
class Meta:
unique_together = [["m2m"]]
self.assertEqual(
Model.check(),
[
Error(
"'unique_together' refers to a ManyToManyField 'm2m', but "
"ManyToManyFields are not permitted in 'unique_together'.",
obj=Model,
id="models.E013",
),
],
)
def test_pointing_to_fk(self):
class Foo(models.Model):
pass
class Bar(models.Model):
foo_1 = models.ForeignKey(
Foo, on_delete=models.CASCADE, related_name="bar_1"
)
foo_2 = models.ForeignKey(
Foo, on_delete=models.CASCADE, related_name="bar_2"
)
class Meta:
unique_together = [["foo_1_id", "foo_2"]]
self.assertEqual(Bar.check(), [])
def test_pointing_to_composite_primary_key(self):
class Model(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Meta:
unique_together = [["pk"]]
self.assertEqual(
Model.check(),
[
Error(
"'unique_together' refers to a CompositePrimaryKey 'pk', but "
"CompositePrimaryKeys are not permitted in 'unique_together'.",
obj=Model,
id="models.E048",
),
],
)
def test_pointing_to_foreign_object(self):
class Reference(models.Model):
reference_id = models.IntegerField(unique=True)
class ReferenceTab(models.Model):
reference_id = models.IntegerField()
reference = models.ForeignObject(
Reference,
from_fields=["reference_id"],
to_fields=["reference_id"],
on_delete=models.CASCADE,
)
class Meta:
unique_together = [["reference"]]
self.assertEqual(ReferenceTab.check(), [])
def test_pointing_to_foreign_object_multi_column(self):
class Reference(models.Model):
reference_id = models.IntegerField(unique=True)
code = models.CharField(max_length=1)
class ReferenceTabMultiple(models.Model):
reference_id = models.IntegerField()
code = models.CharField(max_length=1)
reference = models.ForeignObject(
Reference,
from_fields=["reference_id", "code"],
to_fields=["reference_id", "code"],
on_delete=models.CASCADE,
)
class Meta:
unique_together = [["reference"]]
self.assertEqual(
ReferenceTabMultiple.check(),
[
Error(
"'unique_together' refers to a ForeignObject 'reference' with "
"multiple 'from_fields', which is not supported for that option.",
obj=ReferenceTabMultiple,
id="models.E049",
),
],
)
@isolate_apps("invalid_models_tests")
class IndexesTests(TestCase):
def test_pointing_to_missing_field(self):
class Model(models.Model):
class Meta:
indexes = [models.Index(fields=["missing_field"], name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to the nonexistent field 'missing_field'.",
obj=Model,
id="models.E012",
),
],
)
def test_pointing_to_desc_field(self):
class Model(models.Model):
name = models.CharField(max_length=100)
class Meta:
indexes = [models.Index(fields=["-name"], name="index_name")]
self.assertEqual(Model.check(databases=self.databases), [])
def test_pointing_to_m2m_field(self):
class Model(models.Model):
m2m = models.ManyToManyField("self")
class Meta:
indexes = [models.Index(fields=["m2m"], name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a ManyToManyField 'm2m', but "
"ManyToManyFields are not permitted in 'indexes'.",
obj=Model,
id="models.E013",
),
],
)
def test_pointing_to_non_local_field(self):
class Foo(models.Model):
field1 = models.IntegerField()
class Bar(Foo):
field2 = models.IntegerField()
class Meta:
indexes = [models.Index(fields=["field2", "field1"], name="name")]
self.assertEqual(
Bar.check(databases=self.databases),
[
Error(
"'indexes' refers to field 'field1' which is not local to "
"model 'Bar'.",
hint="This issue may be caused by multi-table inheritance.",
obj=Bar,
id="models.E016",
),
],
)
def test_pointing_to_fk(self):
class Foo(models.Model):
pass
class Bar(models.Model):
foo_1 = models.ForeignKey(
Foo, on_delete=models.CASCADE, related_name="bar_1"
)
foo_2 = models.ForeignKey(
Foo, on_delete=models.CASCADE, related_name="bar_2"
)
class Meta:
indexes = [
models.Index(fields=["foo_1_id", "foo_2"], name="index_name")
]
self.assertEqual(Bar.check(databases=self.databases), [])
def test_pointing_to_composite_primary_key(self):
class Model(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Meta:
indexes = [models.Index(fields=["pk", "name"], name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a CompositePrimaryKey 'pk', but "
"CompositePrimaryKeys are not permitted in 'indexes'.",
obj=Model,
id="models.E048",
),
],
)
def test_name_constraints(self):
class Model(models.Model):
class Meta:
indexes = [
models.Index(fields=["id"], name="_index_name"),
models.Index(fields=["id"], name="5index_name"),
]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"The index name '%sindex_name' cannot start with an "
"underscore or a number." % prefix,
obj=Model,
id="models.E033",
)
for prefix in ("_", "5")
],
)
def test_max_name_length(self):
index_name = "x" * 31
class Model(models.Model):
class Meta:
indexes = [models.Index(fields=["id"], name=index_name)]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"The index name '%s' cannot be longer than 30 characters."
% index_name,
obj=Model,
id="models.E034",
),
],
)
def test_index_with_condition(self):
class Model(models.Model):
age = models.IntegerField()
class Meta:
indexes = [
models.Index(
fields=["age"],
name="index_age_gte_10",
condition=models.Q(age__gte=10),
),
]
errors = Model.check(databases=self.databases)
expected = (
[]
if connection.features.supports_partial_indexes
else [
Warning(
"%s does not support indexes with conditions."
% connection.display_name,
hint=(
"Conditions will be ignored. Silence this warning if you "
"don't care about it."
),
obj=Model,
id="models.W037",
)
]
)
self.assertEqual(errors, expected)
def test_index_with_condition_required_db_features(self):
class Model(models.Model):
age = models.IntegerField()
class Meta:
required_db_features = {"supports_partial_indexes"}
indexes = [
models.Index(
fields=["age"],
name="index_age_gte_10",
condition=models.Q(age__gte=10),
),
]
self.assertEqual(Model.check(databases=self.databases), [])
def test_index_with_include(self):
class Model(models.Model):
age = models.IntegerField()
class Meta:
indexes = [
models.Index(
fields=["age"],
name="index_age_include_id",
include=["id"],
),
]
errors = Model.check(databases=self.databases)
expected = (
[]
if connection.features.supports_covering_indexes
else [
Warning(
"%s does not support indexes with non-key columns."
% connection.display_name,
hint=(
"Non-key columns will be ignored. Silence this warning if "
"you don't care about it."
),
obj=Model,
id="models.W040",
)
]
)
self.assertEqual(errors, expected)
def test_index_with_include_required_db_features(self):
class Model(models.Model):
age = models.IntegerField()
class Meta:
required_db_features = {"supports_covering_indexes"}
indexes = [
models.Index(
fields=["age"],
name="index_age_include_id",
include=["id"],
),
]
self.assertEqual(Model.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_covering_indexes")
def test_index_include_pointing_to_missing_field(self):
class Model(models.Model):
class Meta:
indexes = [
models.Index(fields=["id"], include=["missing_field"], name="name"),
]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to the nonexistent field 'missing_field'.",
obj=Model,
id="models.E012",
),
],
)
@skipUnlessDBFeature("supports_covering_indexes")
def test_index_include_pointing_to_m2m_field(self):
class Model(models.Model):
m2m = models.ManyToManyField("self")
class Meta:
indexes = [models.Index(fields=["id"], include=["m2m"], name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a ManyToManyField 'm2m', but "
"ManyToManyFields are not permitted in 'indexes'.",
obj=Model,
id="models.E013",
),
],
)
@skipUnlessDBFeature("supports_covering_indexes")
def test_index_include_pointing_to_non_local_field(self):
class Parent(models.Model):
field1 = models.IntegerField()
class Child(Parent):
field2 = models.IntegerField()
class Meta:
indexes = [
models.Index(fields=["field2"], include=["field1"], name="name"),
]
self.assertEqual(
Child.check(databases=self.databases),
[
Error(
"'indexes' refers to field 'field1' which is not local to "
"model 'Child'.",
hint="This issue may be caused by multi-table inheritance.",
obj=Child,
id="models.E016",
),
],
)
@skipUnlessDBFeature("supports_covering_indexes")
def test_index_include_pointing_to_fk(self):
class Target(models.Model):
pass
class Model(models.Model):
fk_1 = models.ForeignKey(Target, models.CASCADE, related_name="target_1")
fk_2 = models.ForeignKey(Target, models.CASCADE, related_name="target_2")
class Meta:
indexes = [
models.Index(
fields=["id"],
include=["fk_1_id", "fk_2"],
name="name",
),
]
self.assertEqual(Model.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_covering_indexes")
def test_index_include_pointing_to_composite_primary_key(self):
class Model(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Meta:
indexes = [models.Index(fields=["name"], include=["pk"], name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a CompositePrimaryKey 'pk', but "
"CompositePrimaryKeys are not permitted in 'indexes'.",
obj=Model,
id="models.E048",
),
],
)
def test_func_index(self):
class Model(models.Model):
name = models.CharField(max_length=10)
class Meta:
indexes = [models.Index(Lower("name"), name="index_lower_name")]
warn = Warning(
"%s does not support indexes on expressions." % connection.display_name,
hint=(
"An index won't be created. Silence this warning if you don't "
"care about it."
),
obj=Model,
id="models.W043",
)
expected = [] if connection.features.supports_expression_indexes else [warn]
self.assertEqual(Model.check(databases=self.databases), expected)
def test_func_index_required_db_features(self):
class Model(models.Model):
name = models.CharField(max_length=10)
class Meta:
indexes = [models.Index(Lower("name"), name="index_lower_name")]
required_db_features = {"supports_expression_indexes"}
self.assertEqual(Model.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_complex_expression_custom_lookup(self):
class Model(models.Model):
height = models.IntegerField()
weight = models.IntegerField()
class Meta:
indexes = [
models.Index(
models.F("height")
/ (models.F("weight__abs") + models.Value(5)),
name="name",
),
]
with register_lookup(models.IntegerField, Abs):
self.assertEqual(Model.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_missing_field(self):
class Model(models.Model):
class Meta:
indexes = [models.Index(Lower("missing_field").desc(), name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to the nonexistent field 'missing_field'.",
obj=Model,
id="models.E012",
),
],
)
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_missing_field_nested(self):
class Model(models.Model):
class Meta:
indexes = [
models.Index(Abs(Round("missing_field")), name="name"),
]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to the nonexistent field 'missing_field'.",
obj=Model,
id="models.E012",
),
],
)
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_m2m_field(self):
class Model(models.Model):
m2m = models.ManyToManyField("self")
class Meta:
indexes = [models.Index(Lower("m2m"), name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a ManyToManyField 'm2m', but "
"ManyToManyFields are not permitted in 'indexes'.",
obj=Model,
id="models.E013",
),
],
)
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_non_local_field(self):
class Foo(models.Model):
field1 = models.CharField(max_length=15)
class Bar(Foo):
class Meta:
indexes = [models.Index(Lower("field1"), name="name")]
self.assertEqual(
Bar.check(databases=self.databases),
[
Error(
"'indexes' refers to field 'field1' which is not local to "
"model 'Bar'.",
hint="This issue may be caused by multi-table inheritance.",
obj=Bar,
id="models.E016",
),
],
)
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_fk(self):
class Foo(models.Model):
pass
class Bar(models.Model):
foo_1 = models.ForeignKey(Foo, models.CASCADE, related_name="bar_1")
foo_2 = models.ForeignKey(Foo, models.CASCADE, related_name="bar_2")
class Meta:
indexes = [
models.Index(Lower("foo_1_id"), Lower("foo_2"), name="index_name"),
]
self.assertEqual(Bar.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_expression_indexes")
def test_func_index_pointing_to_composite_primary_key(self):
class Model(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Meta:
indexes = [models.Index(Abs("pk"), name="name")]
self.assertEqual(
Model.check(databases=self.databases),
[
Error(
"'indexes' refers to a CompositePrimaryKey 'pk', but "
"CompositePrimaryKeys are not permitted in 'indexes'.",
obj=Model,
id="models.E048",
),
],
)
@isolate_apps("invalid_models_tests")
class FieldNamesTests(TestCase):
databases = {"default", "other"}
def test_ending_with_underscore(self):
class Model(models.Model):
field_ = models.CharField(max_length=10)
m2m_ = models.ManyToManyField("self")
self.assertEqual(
Model.check(),
[
Error(
"Field names must not end with an underscore.",
obj=Model._meta.get_field("field_"),
id="fields.E001",
),
Error(
"Field names must not end with an underscore.",
obj=Model._meta.get_field("m2m_"),
id="fields.E001",
),
],
)
max_column_name_length, column_limit_db_alias = get_max_column_name_length()
@unittest.skipIf(
max_column_name_length is None,
"The database doesn't have a column name length limit.",
)
def test_M2M_long_column_name(self):
"""
#13711 -- Model check for long M2M column names when database has
column name length limits.
"""
# A model with very long name which will be used to set relations to.
class VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz(
models.Model
):
title = models.CharField(max_length=11)
# Main model for which checks will be performed.
class ModelWithLongField(models.Model):
m2m_field = models.ManyToManyField(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
related_name="rn1",
)
m2m_field2 = models.ManyToManyField(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
related_name="rn2",
through="m2msimple",
)
m2m_field3 = models.ManyToManyField(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
related_name="rn3",
through="m2mcomplex",
)
fk = models.ForeignKey(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
models.CASCADE,
related_name="rn4",
)
# Models used for setting `through` in M2M field.
class m2msimple(models.Model):
id2 = models.ForeignKey(ModelWithLongField, models.CASCADE)
class m2mcomplex(models.Model):
id2 = models.ForeignKey(ModelWithLongField, models.CASCADE)
long_field_name = "a" * (self.max_column_name_length + 1)
models.ForeignKey(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
models.CASCADE,
).contribute_to_class(m2msimple, long_field_name)
models.ForeignKey(
VeryLongModelNamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
models.CASCADE,
db_column=long_field_name,
).contribute_to_class(m2mcomplex, long_field_name)
errors = ModelWithLongField.check(databases=("default", "other"))
# First error because of M2M field set on the model with long name.
m2m_long_name = (
"verylongmodelnamezzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz_id"
)
if self.max_column_name_length > len(m2m_long_name):
# Some databases support names longer than the test name.
expected = []
else:
expected = [
Error(
'Autogenerated column name too long for M2M field "%s". '
'Maximum length is "%s" for database "%s".'
% (
m2m_long_name,
self.max_column_name_length,
self.column_limit_db_alias,
),
hint="Use 'through' to create a separate model for "
"M2M and then set column_name using 'db_column'.",
obj=ModelWithLongField,
id="models.E019",
)
]
# Second error because the FK specified in the `through` model
# `m2msimple` has auto-generated name longer than allowed.
# There will be no check errors in the other M2M because it
# specifies db_column for the FK in `through` model even if the actual
# name is longer than the limits of the database.
expected.append(
Error(
'Autogenerated column name too long for M2M field "%s_id". '
'Maximum length is "%s" for database "%s".'
% (
long_field_name,
self.max_column_name_length,
self.column_limit_db_alias,
),
hint="Use 'through' to create a separate model for "
"M2M and then set column_name using 'db_column'.",
obj=ModelWithLongField,
id="models.E019",
)
)
self.assertEqual(errors, expected)
# Check for long column names is called only for specified database
# aliases.
self.assertEqual(ModelWithLongField.check(databases=None), [])
@unittest.skipIf(
max_column_name_length is None,
"The database doesn't have a column name length limit.",
)
def test_local_field_long_column_name(self):
"""
#13711 -- Model check for long column names
when database does not support long names.
"""
class ModelWithLongField(models.Model):
title = models.CharField(max_length=11)
long_field_name = "a" * (self.max_column_name_length + 1)
long_field_name2 = "b" * (self.max_column_name_length + 1)
models.CharField(max_length=11).contribute_to_class(
ModelWithLongField, long_field_name
)
models.CharField(max_length=11, db_column="vlmn").contribute_to_class(
ModelWithLongField, long_field_name2
)
self.assertEqual(
ModelWithLongField.check(databases=("default", "other")),
[
Error(
'Autogenerated column name too long for field "%s". '
'Maximum length is "%s" for database "%s".'
% (
long_field_name,
self.max_column_name_length,
self.column_limit_db_alias,
),
hint="Set the column name manually using 'db_column'.",
obj=ModelWithLongField,
id="models.E018",
)
],
)
# Check for long column names is called only for specified database
# aliases.
self.assertEqual(ModelWithLongField.check(databases=None), [])
def test_including_separator(self):
class Model(models.Model):
some__field = models.IntegerField()
self.assertEqual(
Model.check(),
[
Error(
'Field names must not contain "__".',
obj=Model._meta.get_field("some__field"),
id="fields.E002",
)
],
)
def test_pk(self):
class Model(models.Model):
pk = models.IntegerField()
self.assertEqual(
Model.check(),
[
Error(
"'pk' is a reserved word that cannot be used as a field name.",
obj=Model._meta.get_field("pk"),
id="fields.E003",
)
],
)
def test_db_column_clash(self):
class Model(models.Model):
foo = models.IntegerField()
bar = models.IntegerField(db_column="foo")
self.assertEqual(
Model.check(),
[
Error(
"Field 'bar' has column name 'foo' that is used by "
"another field.",
hint="Specify a 'db_column' for the field.",
obj=Model,
id="models.E007",
)
],
)
@isolate_apps("invalid_models_tests")
class ShadowingFieldsTests(SimpleTestCase):
def test_field_name_clash_with_child_accessor(self):
class Parent(models.Model):
pass
class Child(Parent):
child = models.CharField(max_length=100)
self.assertEqual(
Child.check(),
[
Error(
"The field 'child' clashes with the field "
"'child' from model 'invalid_models_tests.parent'.",
obj=Child._meta.get_field("child"),
id="models.E006",
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_custom_fields.py | tests/invalid_models_tests/test_custom_fields.py | from django.db import models
from django.test import SimpleTestCase
from django.test.utils import isolate_apps
@isolate_apps("invalid_models_tests")
class CustomFieldTest(SimpleTestCase):
def test_none_column(self):
class NoColumnField(models.AutoField):
def db_type(self, connection):
# None indicates not to create a column in the database.
return None
class Model(models.Model):
field = NoColumnField(primary_key=True, db_column="other_field")
other_field = models.IntegerField()
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_backend_specific.py | tests/invalid_models_tests/test_backend_specific.py | from unittest import mock
from django.core.checks import Error
from django.db import connections, models
from django.test import SimpleTestCase
from django.test.utils import isolate_apps
def dummy_allow_migrate(db, app_label, **hints):
# Prevent checks from being run on the 'other' database, which doesn't have
# its check_field() method mocked in the test.
return db == "default"
@isolate_apps("invalid_models_tests")
class BackendSpecificChecksTests(SimpleTestCase):
@mock.patch("django.db.models.fields.router.allow_migrate", new=dummy_allow_migrate)
def test_check_field(self):
"""Test if backend specific checks are performed."""
error = Error("an error")
class Model(models.Model):
field = models.IntegerField()
field = Model._meta.get_field("field")
with mock.patch.object(
connections["default"].validation, "check_field", return_value=[error]
):
self.assertEqual(field.check(databases={"default"}), [error])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_deprecated_fields.py | tests/invalid_models_tests/test_deprecated_fields.py | from unittest import skipUnless
from django.core import checks
from django.db import connection, models
from django.test import SimpleTestCase
from django.test.utils import isolate_apps, modify_settings
@isolate_apps("invalid_models_tests")
class DeprecatedFieldsTests(SimpleTestCase):
def test_IPAddressField_deprecated(self):
class IPAddressModel(models.Model):
ip = models.IPAddressField()
model = IPAddressModel()
self.assertEqual(
model.check(),
[
checks.Error(
"IPAddressField has been removed except for support in "
"historical migrations.",
hint="Use GenericIPAddressField instead.",
obj=IPAddressModel._meta.get_field("ip"),
id="fields.E900",
)
],
)
def test_CommaSeparatedIntegerField_deprecated(self):
class CommaSeparatedIntegerModel(models.Model):
csi = models.CommaSeparatedIntegerField(max_length=64)
model = CommaSeparatedIntegerModel()
self.assertEqual(
model.check(),
[
checks.Error(
"CommaSeparatedIntegerField is removed except for support in "
"historical migrations.",
hint=(
"Use "
"CharField(validators=[validate_comma_separated_integer_list]) "
"instead."
),
obj=CommaSeparatedIntegerModel._meta.get_field("csi"),
id="fields.E901",
)
],
)
def test_nullbooleanfield_deprecated(self):
class NullBooleanFieldModel(models.Model):
nb = models.NullBooleanField()
model = NullBooleanFieldModel()
self.assertEqual(
model.check(),
[
checks.Error(
"NullBooleanField is removed except for support in historical "
"migrations.",
hint="Use BooleanField(null=True, blank=True) instead.",
obj=NullBooleanFieldModel._meta.get_field("nb"),
id="fields.E903",
),
],
)
@skipUnless(connection.vendor == "postgresql", "PostgreSQL specific SQL")
def test_postgres_jsonfield_deprecated(self):
from django.contrib.postgres.fields import JSONField
class PostgresJSONFieldModel(models.Model):
field = JSONField()
self.assertEqual(
PostgresJSONFieldModel.check(),
[
checks.Error(
"django.contrib.postgres.fields.JSONField is removed except "
"for support in historical migrations.",
hint="Use django.db.models.JSONField instead.",
obj=PostgresJSONFieldModel._meta.get_field("field"),
id="fields.E904",
),
],
)
@skipUnless(connection.vendor == "postgresql", "PostgreSQL specific SQL")
@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
def test_postgres_ci_fields_deprecated(self):
from django.contrib.postgres.fields import (
ArrayField,
CICharField,
CIEmailField,
CITextField,
)
class PostgresCIFieldsModel(models.Model):
ci_char = CICharField(max_length=255)
ci_email = CIEmailField()
ci_text = CITextField()
array_ci_text = ArrayField(CITextField())
self.assertEqual(
PostgresCIFieldsModel.check(),
[
checks.Error(
"django.contrib.postgres.fields.CICharField is removed except for "
"support in historical migrations.",
hint=(
'Use CharField(db_collation="…") with a case-insensitive '
"non-deterministic collation instead."
),
obj=PostgresCIFieldsModel._meta.get_field("ci_char"),
id="fields.E905",
),
checks.Error(
"django.contrib.postgres.fields.CIEmailField is removed except for "
"support in historical migrations.",
hint=(
'Use EmailField(db_collation="…") with a case-insensitive '
"non-deterministic collation instead."
),
obj=PostgresCIFieldsModel._meta.get_field("ci_email"),
id="fields.E906",
),
checks.Error(
"django.contrib.postgres.fields.CITextField is removed except for "
"support in historical migrations.",
hint=(
'Use TextField(db_collation="…") with a case-insensitive '
"non-deterministic collation instead."
),
obj=PostgresCIFieldsModel._meta.get_field("ci_text"),
id="fields.E907",
),
checks.Error(
"Base field for array has errors:\n"
" django.contrib.postgres.fields.CITextField is removed except "
"for support in historical migrations. (fields.E907)",
obj=PostgresCIFieldsModel._meta.get_field("array_ci_text"),
id="postgres.E001",
),
],
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_ordinary_fields.py | tests/invalid_models_tests/test_ordinary_fields.py | import unittest
import uuid
from django.core.checks import Error
from django.core.checks import Warning as DjangoWarning
from django.db import connection, models
from django.db.models.functions import Coalesce, LPad, Pi
from django.test import SimpleTestCase, TestCase, skipIfDBFeature, skipUnlessDBFeature
from django.test.utils import isolate_apps, override_settings
from django.utils.functional import lazy
from django.utils.timezone import now
from django.utils.translation import gettext_lazy as _
from django.utils.version import get_docs_version
@isolate_apps("invalid_models_tests")
class AutoFieldTests(SimpleTestCase):
def test_valid_case(self):
class Model(models.Model):
id = models.AutoField(primary_key=True)
field = Model._meta.get_field("id")
self.assertEqual(field.check(), [])
def test_primary_key(self):
# primary_key must be True. Refs #12467.
class Model(models.Model):
field = models.AutoField(primary_key=False)
# Prevent Django from autocreating `id` AutoField, which would
# result in an error, because a model must have exactly one
# AutoField.
another = models.IntegerField(primary_key=True)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"AutoFields must set primary_key=True.",
obj=field,
id="fields.E100",
),
],
)
def test_max_length_warning(self):
class Model(models.Model):
auto = models.AutoField(primary_key=True, max_length=2)
field = Model._meta.get_field("auto")
self.assertEqual(
field.check(),
[
DjangoWarning(
"'max_length' is ignored when used with %s."
% field.__class__.__name__,
hint="Remove 'max_length' from field",
obj=field,
id="fields.W122",
),
],
)
@isolate_apps("invalid_models_tests")
class BinaryFieldTests(SimpleTestCase):
def test_valid_default_value(self):
class Model(models.Model):
field1 = models.BinaryField(default=b"test")
field2 = models.BinaryField(default=None)
for field_name in ("field1", "field2"):
field = Model._meta.get_field(field_name)
self.assertEqual(field.check(), [])
def test_str_default_value(self):
class Model(models.Model):
field = models.BinaryField(default="test")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"BinaryField's default cannot be a string. Use bytes content "
"instead.",
obj=field,
id="fields.E170",
),
],
)
@isolate_apps("invalid_models_tests")
class CharFieldTests(TestCase):
def test_valid_field(self):
class Model(models.Model):
field = models.CharField(
max_length=255,
choices=[
("1", "item1"),
("2", "item2"),
],
db_index=True,
)
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
def test_missing_max_length(self):
class Model(models.Model):
field = models.CharField()
field = Model._meta.get_field("field")
expected = (
[]
if connection.features.supports_unlimited_charfield
else [
Error(
"CharFields must define a 'max_length' attribute.",
obj=field,
id="fields.E120",
),
]
)
self.assertEqual(field.check(), expected)
def test_negative_max_length(self):
class Model(models.Model):
field = models.CharField(max_length=-1)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'max_length' must be a positive integer.",
obj=field,
id="fields.E121",
),
],
)
def test_bad_max_length_value(self):
class Model(models.Model):
field = models.CharField(max_length="bad")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'max_length' must be a positive integer.",
obj=field,
id="fields.E121",
),
],
)
def test_str_max_length_value(self):
class Model(models.Model):
field = models.CharField(max_length="20")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'max_length' must be a positive integer.",
obj=field,
id="fields.E121",
),
],
)
def test_str_max_length_type(self):
class Model(models.Model):
field = models.CharField(max_length=True)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'max_length' must be a positive integer.",
obj=field,
id="fields.E121",
),
],
)
def test_non_iterable_choices(self):
class Model(models.Model):
field = models.CharField(max_length=10, choices="bad")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping (e.g. a dictionary) or an "
"ordered iterable (e.g. a list or tuple, but not a set).",
obj=field,
id="fields.E004",
),
],
)
def test_non_iterable_choices_two_letters(self):
"""Two letters isn't a valid choice pair."""
class Model(models.Model):
field = models.CharField(max_length=10, choices=["ab"])
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping of actual values to human readable "
"names or an iterable containing (actual value, human readable "
"name) tuples.",
obj=field,
id="fields.E005",
),
],
)
def test_iterable_of_iterable_choices(self):
class ThingItem:
def __init__(self, value, display):
self.value = value
self.display = display
def __iter__(self):
return iter((self.value, self.display))
def __len__(self):
return 2
class Things:
def __iter__(self):
return iter((ThingItem(1, 2), ThingItem(3, 4)))
class ThingWithIterableChoices(models.Model):
thing = models.CharField(max_length=100, blank=True, choices=Things())
self.assertEqual(ThingWithIterableChoices._meta.get_field("thing").check(), [])
def test_choices_containing_non_pairs(self):
class Model(models.Model):
field = models.CharField(max_length=10, choices=[(1, 2, 3), (1, 2, 3)])
class Model2(models.Model):
field = models.IntegerField(choices=[0])
for model in (Model, Model2):
with self.subTest(model.__name__):
field = model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping of actual values to human "
"readable names or an iterable containing (actual value, "
"human readable name) tuples.",
obj=field,
id="fields.E005",
),
],
)
def test_choices_containing_lazy(self):
class Model(models.Model):
field = models.CharField(
max_length=10, choices=[["1", _("1")], ["2", _("2")]]
)
self.assertEqual(Model._meta.get_field("field").check(), [])
def test_lazy_choices(self):
class Model(models.Model):
field = models.CharField(
max_length=10, choices=lazy(lambda: [[1, "1"], [2, "2"]], tuple)()
)
self.assertEqual(Model._meta.get_field("field").check(), [])
def test_choices_named_group(self):
class Model(models.Model):
field = models.CharField(
max_length=10,
choices=[
["knights", [["L", "Lancelot"], ["G", "Galahad"]]],
["wizards", [["T", "Tim the Enchanter"]]],
["R", "Random character"],
],
)
self.assertEqual(Model._meta.get_field("field").check(), [])
def test_choices_named_group_non_pairs(self):
class Model(models.Model):
field = models.CharField(
max_length=10,
choices=[["knights", [["L", "Lancelot", "Du Lac"]]]],
)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping of actual values to human readable "
"names or an iterable containing (actual value, human readable "
"name) tuples.",
obj=field,
id="fields.E005",
),
],
)
def test_choices_named_group_bad_structure(self):
class Model(models.Model):
field = models.CharField(
max_length=10,
choices=[
[
"knights",
[
["Noble", [["G", "Galahad"]]],
["Combative", [["L", "Lancelot"]]],
],
],
],
)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping of actual values to human readable "
"names or an iterable containing (actual value, human readable "
"name) tuples.",
obj=field,
id="fields.E005",
),
],
)
def test_choices_named_group_lazy(self):
class Model(models.Model):
field = models.CharField(
max_length=10,
choices=[
[_("knights"), [["L", _("Lancelot")], ["G", _("Galahad")]]],
["R", _("Random character")],
],
)
self.assertEqual(Model._meta.get_field("field").check(), [])
def test_choices_in_max_length(self):
class Model(models.Model):
field = models.CharField(
max_length=2,
choices=[("ABC", "Value Too Long!"), ("OK", "Good")],
)
group = models.CharField(
max_length=2,
choices=[
("Nested", [("OK", "Good"), ("Longer", "Longer")]),
("Grouped", [("Bad", "Bad")]),
],
)
for name, choice_max_length in (("field", 3), ("group", 6)):
with self.subTest(name):
field = Model._meta.get_field(name)
self.assertEqual(
field.check(),
[
Error(
"'max_length' is too small to fit the longest value "
"in 'choices' (%d characters)." % choice_max_length,
obj=field,
id="fields.E009",
),
],
)
def test_bad_db_index_value(self):
class Model(models.Model):
field = models.CharField(max_length=10, db_index="bad")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'db_index' must be None, True or False.",
obj=field,
id="fields.E006",
),
],
)
def test_bad_validators(self):
class Model(models.Model):
field = models.CharField(max_length=10, validators=[True])
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"All 'validators' must be callable.",
hint=(
"validators[0] (True) isn't a function or instance of a "
"validator class."
),
obj=field,
id="fields.E008",
),
],
)
@unittest.skipUnless(connection.vendor == "mysql", "Test valid only for MySQL")
def test_too_long_char_field_under_mysql(self):
from django.db.backends.mysql.validation import DatabaseValidation
class Model(models.Model):
field = models.CharField(unique=True, max_length=256)
field = Model._meta.get_field("field")
validator = DatabaseValidation(connection=connection)
self.assertEqual(
validator.check_field(field),
[
DjangoWarning(
"%s may not allow unique CharFields to have a max_length > "
"255." % connection.display_name,
hint=(
"See: https://docs.djangoproject.com/en/%s/ref/databases/"
"#mysql-character-fields" % get_docs_version()
),
obj=field,
id="mysql.W003",
)
],
)
def test_db_collation(self):
class Model(models.Model):
field = models.CharField(max_length=100, db_collation="anything")
field = Model._meta.get_field("field")
error = Error(
"%s does not support a database collation on CharFields."
% connection.display_name,
id="fields.E190",
obj=field,
)
expected = (
[] if connection.features.supports_collation_on_charfield else [error]
)
self.assertEqual(field.check(databases=self.databases), expected)
def test_db_collation_required_db_features(self):
class Model(models.Model):
field = models.CharField(max_length=100, db_collation="anything")
class Meta:
required_db_features = {"supports_collation_on_charfield"}
field = Model._meta.get_field("field")
self.assertEqual(field.check(databases=self.databases), [])
@isolate_apps("invalid_models_tests")
class DateFieldTests(SimpleTestCase):
maxDiff = None
def test_auto_now_and_auto_now_add_raise_error(self):
class Model(models.Model):
field0 = models.DateTimeField(auto_now=True, auto_now_add=True, default=now)
field1 = models.DateTimeField(
auto_now=True, auto_now_add=False, default=now
)
field2 = models.DateTimeField(
auto_now=False, auto_now_add=True, default=now
)
field3 = models.DateTimeField(
auto_now=True, auto_now_add=True, default=None
)
expected = []
checks = []
for i in range(4):
field = Model._meta.get_field("field%d" % i)
expected.append(
Error(
"The options auto_now, auto_now_add, and default "
"are mutually exclusive. Only one of these options "
"may be present.",
obj=field,
id="fields.E160",
)
)
checks.extend(field.check())
self.assertEqual(checks, expected)
def test_fix_default_value(self):
class Model(models.Model):
field_dt = models.DateField(default=now())
field_d = models.DateField(default=now().date())
field_now = models.DateField(default=now)
field_dt = Model._meta.get_field("field_dt")
field_d = Model._meta.get_field("field_d")
field_now = Model._meta.get_field("field_now")
errors = field_dt.check()
errors.extend(field_d.check())
errors.extend(field_now.check()) # doesn't raise a warning
self.assertEqual(
errors,
[
DjangoWarning(
"Fixed default value provided.",
hint="It seems you set a fixed date / time / datetime "
"value as default for this field. This may not be "
"what you want. If you want to have the current date "
"as default, use `django.utils.timezone.now`",
obj=field_dt,
id="fields.W161",
),
DjangoWarning(
"Fixed default value provided.",
hint="It seems you set a fixed date / time / datetime "
"value as default for this field. This may not be "
"what you want. If you want to have the current date "
"as default, use `django.utils.timezone.now`",
obj=field_d,
id="fields.W161",
),
],
)
@override_settings(USE_TZ=True)
def test_fix_default_value_tz(self):
self.test_fix_default_value()
@isolate_apps("invalid_models_tests")
class DateTimeFieldTests(SimpleTestCase):
maxDiff = None
def test_fix_default_value(self):
class Model(models.Model):
field_dt = models.DateTimeField(default=now())
field_d = models.DateTimeField(default=now().date())
field_now = models.DateTimeField(default=now)
field_dt = Model._meta.get_field("field_dt")
field_d = Model._meta.get_field("field_d")
field_now = Model._meta.get_field("field_now")
errors = field_dt.check()
errors.extend(field_d.check())
errors.extend(field_now.check()) # doesn't raise a warning
self.assertEqual(
errors,
[
DjangoWarning(
"Fixed default value provided.",
hint="It seems you set a fixed date / time / datetime "
"value as default for this field. This may not be "
"what you want. If you want to have the current date "
"as default, use `django.utils.timezone.now`",
obj=field_dt,
id="fields.W161",
),
DjangoWarning(
"Fixed default value provided.",
hint="It seems you set a fixed date / time / datetime "
"value as default for this field. This may not be "
"what you want. If you want to have the current date "
"as default, use `django.utils.timezone.now`",
obj=field_d,
id="fields.W161",
),
],
)
@override_settings(USE_TZ=True)
def test_fix_default_value_tz(self):
self.test_fix_default_value()
@isolate_apps("invalid_models_tests")
class DecimalFieldTests(TestCase):
def test_both_attributes_omitted(self):
class Model(models.Model):
field = models.DecimalField()
field = Model._meta.get_field("field")
if connection.features.supports_no_precision_decimalfield:
expected = []
else:
expected = [
Error(
"DecimalFields must define a 'decimal_places' attribute.",
obj=field,
id="fields.E130",
),
Error(
"DecimalFields must define a 'max_digits' attribute.",
obj=field,
id="fields.E132",
),
]
self.assertEqual(field.check(databases=self.databases), expected)
def test_both_attributes_omitted_required_db_features(self):
class Model(models.Model):
field = models.DecimalField()
class Meta:
required_db_features = {"supports_no_precision_decimalfield"}
field = Model._meta.get_field("field")
self.assertEqual(field.check(databases=self.databases), [])
@skipUnlessDBFeature("supports_no_precision_decimalfield")
def test_only_max_digits_defined(self):
class Model(models.Model):
field = models.DecimalField(max_digits=13)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(databases=self.databases),
[
Error(
"DecimalField’s max_digits and decimal_places must both "
"be defined or both omitted.",
obj=field,
id="fields.E135",
),
],
)
@skipUnlessDBFeature("supports_no_precision_decimalfield")
def test_only_decimal_places_defined(self):
class Model(models.Model):
field = models.DecimalField(decimal_places=5)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(databases=self.databases),
[
Error(
"DecimalField’s max_digits and decimal_places must both "
"be defined or both omitted.",
obj=field,
id="fields.E135",
),
],
)
def test_negative_max_digits_and_decimal_places(self):
class Model(models.Model):
field = models.DecimalField(max_digits=-1, decimal_places=-1)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(databases=self.databases),
[
Error(
"'decimal_places' must be a non-negative integer.",
obj=field,
id="fields.E131",
),
Error(
"'max_digits' must be a positive integer.",
obj=field,
id="fields.E133",
),
],
)
def test_bad_values_of_max_digits_and_decimal_places(self):
class Model(models.Model):
field = models.DecimalField(max_digits="bad", decimal_places="bad")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(databases=self.databases),
[
Error(
"'decimal_places' must be a non-negative integer.",
obj=field,
id="fields.E131",
),
Error(
"'max_digits' must be a positive integer.",
obj=field,
id="fields.E133",
),
],
)
def test_decimal_places_greater_than_max_digits(self):
class Model(models.Model):
field = models.DecimalField(max_digits=9, decimal_places=10)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'max_digits' must be greater or equal to 'decimal_places'.",
obj=field,
id="fields.E134",
),
],
)
def test_valid_field(self):
class Model(models.Model):
field = models.DecimalField(max_digits=10, decimal_places=10)
field = Model._meta.get_field("field")
self.assertEqual(field.check(databases=self.databases), [])
@isolate_apps("invalid_models_tests")
class FileFieldTests(SimpleTestCase):
def test_valid_default_case(self):
class Model(models.Model):
field = models.FileField()
self.assertEqual(Model._meta.get_field("field").check(), [])
def test_valid_case(self):
class Model(models.Model):
field = models.FileField(upload_to="somewhere")
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
def test_primary_key(self):
class Model(models.Model):
field = models.FileField(primary_key=False, upload_to="somewhere")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'primary_key' is not a valid argument for a FileField.",
obj=field,
id="fields.E201",
)
],
)
def test_upload_to_starts_with_slash(self):
class Model(models.Model):
field = models.FileField(upload_to="/somewhere")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"FileField's 'upload_to' argument must be a relative path, not "
"an absolute path.",
obj=field,
id="fields.E202",
hint="Remove the leading slash.",
)
],
)
def test_upload_to_callable_not_checked(self):
def callable(instance, filename):
return "/" + filename
class Model(models.Model):
field = models.FileField(upload_to=callable)
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
@isolate_apps("invalid_models_tests")
class FilePathFieldTests(SimpleTestCase):
def test_forbidden_files_and_folders(self):
class Model(models.Model):
field = models.FilePathField(allow_files=False, allow_folders=False)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"FilePathFields must have either 'allow_files' or 'allow_folders' "
"set to True.",
obj=field,
id="fields.E140",
),
],
)
@isolate_apps("invalid_models_tests")
class GenericIPAddressFieldTests(SimpleTestCase):
def test_non_nullable_blank(self):
class Model(models.Model):
field = models.GenericIPAddressField(null=False, blank=True)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
(
"GenericIPAddressFields cannot have blank=True if null=False, "
"as blank values are stored as nulls."
),
obj=field,
id="fields.E150",
),
],
)
@isolate_apps("invalid_models_tests")
class ImageFieldTests(SimpleTestCase):
def test_pillow_installed(self):
try:
from PIL import Image # NOQA
except ImportError:
pillow_installed = False
else:
pillow_installed = True
class Model(models.Model):
field = models.ImageField(upload_to="somewhere")
field = Model._meta.get_field("field")
errors = field.check()
expected = (
[]
if pillow_installed
else [
Error(
"Cannot use ImageField because Pillow is not installed.",
hint=(
"Get Pillow at https://pypi.org/project/Pillow/ "
'or run command "python -m pip install Pillow".'
),
obj=field,
id="fields.E210",
),
]
)
self.assertEqual(errors, expected)
@isolate_apps("invalid_models_tests")
class IntegerFieldTests(SimpleTestCase):
def test_max_length_warning(self):
class Model(models.Model):
integer = models.IntegerField(max_length=2)
biginteger = models.BigIntegerField(max_length=2)
smallinteger = models.SmallIntegerField(max_length=2)
positiveinteger = models.PositiveIntegerField(max_length=2)
positivebiginteger = models.PositiveBigIntegerField(max_length=2)
positivesmallinteger = models.PositiveSmallIntegerField(max_length=2)
for field in Model._meta.get_fields():
if field.auto_created:
continue
with self.subTest(name=field.name):
self.assertEqual(
field.check(),
[
DjangoWarning(
"'max_length' is ignored when used with %s."
% field.__class__.__name__,
hint="Remove 'max_length' from field",
obj=field,
id="fields.W122",
)
],
)
def test_non_iterable_choices(self):
class Model(models.Model):
field = models.IntegerField(choices=123)
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping (e.g. a dictionary) or an "
"ordered iterable (e.g. a list or tuple, but not a set).",
obj=field,
id="fields.E004",
),
],
)
def test_unordered_choices_set(self):
class Model(models.Model):
field = models.IntegerField(choices={1, 2, 3})
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping (e.g. a dictionary) or an "
"ordered iterable (e.g. a list or tuple, but not a set).",
obj=field,
id="fields.E004",
),
],
)
def test_unordered_choices_frozenset(self):
class Model(models.Model):
field = models.IntegerField(choices=frozenset({1, 2, 3}))
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping (e.g. a dictionary) or an "
"ordered iterable (e.g. a list or tuple, but not a set).",
obj=field,
id="fields.E004",
),
],
)
def test_non_iterable_choices_number(self):
"""An integer isn't a valid choice pair."""
class Model(models.Model):
field = models.IntegerField(choices=[123])
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'choices' must be a mapping of actual values to human readable "
"names or an iterable containing (actual value, human readable "
"name) tuples.",
obj=field,
id="fields.E005",
),
],
)
@isolate_apps("invalid_models_tests")
class TimeFieldTests(SimpleTestCase):
maxDiff = None
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/__init__.py | tests/invalid_models_tests/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/invalid_models_tests/test_relative_fields.py | tests/invalid_models_tests/test_relative_fields.py | from unittest import mock
from django.core.checks import Error
from django.core.checks import Warning as DjangoWarning
from django.db import connection, models
from django.test import skipUnlessDBFeature
from django.test.testcases import SimpleTestCase, TestCase
from django.test.utils import isolate_apps, modify_settings, override_settings
@isolate_apps("invalid_models_tests")
class RelativeFieldTests(SimpleTestCase):
def test_valid_foreign_key_without_accessor(self):
class Target(models.Model):
# There would be a clash if Model.field installed an accessor.
model = models.IntegerField()
class Model(models.Model):
field = models.ForeignKey(Target, models.CASCADE, related_name="+")
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
def test_foreign_key_to_missing_model(self):
# Model names are resolved when a model is being created, so we cannot
# test relative fields in isolation and we need to attach them to a
# model.
class Model(models.Model):
foreign_key = models.ForeignKey("Rel1", models.CASCADE)
field = Model._meta.get_field("foreign_key")
self.assertEqual(
field.check(),
[
Error(
"Field defines a relation with model 'Rel1', "
"which is either not installed, or is abstract.",
obj=field,
id="fields.E300",
),
],
)
@isolate_apps("invalid_models_tests")
def test_foreign_key_to_isolate_apps_model(self):
"""
#25723 - Referenced model registration lookup should be run against the
field's model registry.
"""
class OtherModel(models.Model):
pass
class Model(models.Model):
foreign_key = models.ForeignKey("OtherModel", models.CASCADE)
field = Model._meta.get_field("foreign_key")
self.assertEqual(field.check(from_model=Model), [])
def test_many_to_many_to_missing_model(self):
class Model(models.Model):
m2m = models.ManyToManyField("Rel2")
field = Model._meta.get_field("m2m")
self.assertEqual(
field.check(from_model=Model),
[
Error(
"Field defines a relation with model 'Rel2', "
"which is either not installed, or is abstract.",
obj=field,
id="fields.E300",
),
],
)
@isolate_apps("invalid_models_tests")
def test_many_to_many_to_isolate_apps_model(self):
"""
#25723 - Referenced model registration lookup should be run against the
field's model registry.
"""
class OtherModel(models.Model):
pass
class Model(models.Model):
m2m = models.ManyToManyField("OtherModel")
field = Model._meta.get_field("m2m")
self.assertEqual(field.check(from_model=Model), [])
@isolate_apps("invalid_models_tests")
def test_auto_created_through_model(self):
class OtherModel(models.Model):
pass
class M2MModel(models.Model):
many_to_many_rel = models.ManyToManyField(OtherModel)
class O2OModel(models.Model):
one_to_one_rel = models.OneToOneField(
"invalid_models_tests.M2MModel_many_to_many_rel",
on_delete=models.CASCADE,
)
field = O2OModel._meta.get_field("one_to_one_rel")
self.assertEqual(field.check(from_model=O2OModel), [])
def test_many_to_many_with_useless_options(self):
class Model(models.Model):
name = models.CharField(max_length=20)
class ModelM2M(models.Model):
m2m = models.ManyToManyField(
Model, null=True, validators=[lambda x: x], db_comment="Column comment"
)
field = ModelM2M._meta.get_field("m2m")
self.assertEqual(
ModelM2M.check(),
[
DjangoWarning(
"null has no effect on ManyToManyField.",
obj=field,
id="fields.W340",
),
DjangoWarning(
"ManyToManyField does not support validators.",
obj=field,
id="fields.W341",
),
DjangoWarning(
"db_comment has no effect on ManyToManyField.",
obj=field,
id="fields.W346",
),
],
)
def test_many_to_many_with_useless_related_name(self):
class ModelM2M(models.Model):
m2m = models.ManyToManyField("self", related_name="children")
field = ModelM2M._meta.get_field("m2m")
self.assertEqual(
ModelM2M.check(),
[
DjangoWarning(
"related_name has no effect on ManyToManyField with "
'a symmetrical relationship, e.g. to "self".',
obj=field,
id="fields.W345",
),
],
)
def test_ambiguous_relationship_model_from(self):
class Person(models.Model):
pass
class Group(models.Model):
field = models.ManyToManyField("Person", through="AmbiguousRelationship")
class AmbiguousRelationship(models.Model):
person = models.ForeignKey(Person, models.CASCADE)
first_group = models.ForeignKey(Group, models.CASCADE, related_name="first")
second_group = models.ForeignKey(
Group, models.CASCADE, related_name="second"
)
field = Group._meta.get_field("field")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"The model is used as an intermediate model by "
"'invalid_models_tests.Group.field', but it has more than one "
"foreign key from 'Group', which is ambiguous. You must "
"specify which foreign key Django should use via the "
"through_fields keyword argument.",
hint=(
"If you want to create a recursive relationship, use "
'ManyToManyField("self", through="AmbiguousRelationship").'
),
obj=field,
id="fields.E334",
),
],
)
def test_ambiguous_relationship_model_to(self):
class Person(models.Model):
pass
class Group(models.Model):
field = models.ManyToManyField(
"Person", through="AmbiguousRelationship", related_name="tertiary"
)
class AmbiguousRelationship(models.Model):
# Too much foreign keys to Person.
first_person = models.ForeignKey(
Person, models.CASCADE, related_name="first"
)
second_person = models.ForeignKey(
Person, models.CASCADE, related_name="second"
)
second_model = models.ForeignKey(Group, models.CASCADE)
field = Group._meta.get_field("field")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"The model is used as an intermediate model by "
"'invalid_models_tests.Group.field', but it has more than one "
"foreign key to 'Person', which is ambiguous. You must specify "
"which foreign key Django should use via the through_fields "
"keyword argument.",
hint=(
"If you want to create a recursive relationship, use "
'ManyToManyField("self", through="AmbiguousRelationship").'
),
obj=field,
id="fields.E335",
),
],
)
def test_relationship_model_with_foreign_key_to_wrong_model(self):
class WrongModel(models.Model):
pass
class Person(models.Model):
pass
class Group(models.Model):
members = models.ManyToManyField("Person", through="InvalidRelationship")
class InvalidRelationship(models.Model):
person = models.ForeignKey(Person, models.CASCADE)
wrong_foreign_key = models.ForeignKey(WrongModel, models.CASCADE)
# The last foreign key should point to Group model.
field = Group._meta.get_field("members")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"The model is used as an intermediate model by "
"'invalid_models_tests.Group.members', but it does not "
"have a foreign key to 'Group' or 'Person'.",
obj=InvalidRelationship,
id="fields.E336",
),
],
)
def test_relationship_model_missing_foreign_key(self):
class Person(models.Model):
pass
class Group(models.Model):
members = models.ManyToManyField("Person", through="InvalidRelationship")
class InvalidRelationship(models.Model):
group = models.ForeignKey(Group, models.CASCADE)
# No foreign key to Person
field = Group._meta.get_field("members")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"The model is used as an intermediate model by "
"'invalid_models_tests.Group.members', but it does not have "
"a foreign key to 'Group' or 'Person'.",
obj=InvalidRelationship,
id="fields.E336",
),
],
)
def test_missing_relationship_model(self):
class Person(models.Model):
pass
class Group(models.Model):
members = models.ManyToManyField("Person", through="MissingM2MModel")
field = Group._meta.get_field("members")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"Field specifies a many-to-many relation through model "
"'MissingM2MModel', which has not been installed.",
obj=field,
id="fields.E331",
),
],
)
def test_missing_relationship_model_on_model_check(self):
class Person(models.Model):
pass
class Group(models.Model):
members = models.ManyToManyField("Person", through="MissingM2MModel")
self.assertEqual(
Group.check(),
[
Error(
"Field specifies a many-to-many relation through model "
"'MissingM2MModel', which has not been installed.",
obj=Group._meta.get_field("members"),
id="fields.E331",
),
],
)
@isolate_apps("invalid_models_tests")
def test_many_to_many_through_isolate_apps_model(self):
"""
#25723 - Through model registration lookup should be run against the
field's model registry.
"""
class GroupMember(models.Model):
person = models.ForeignKey("Person", models.CASCADE)
group = models.ForeignKey("Group", models.CASCADE)
class Person(models.Model):
pass
class Group(models.Model):
members = models.ManyToManyField("Person", through="GroupMember")
field = Group._meta.get_field("members")
self.assertEqual(field.check(from_model=Group), [])
def test_too_many_foreign_keys_in_self_referential_model(self):
class Person(models.Model):
friends = models.ManyToManyField(
"self", through="InvalidRelationship", symmetrical=False
)
class InvalidRelationship(models.Model):
first = models.ForeignKey(
Person, models.CASCADE, related_name="rel_from_set_2"
)
second = models.ForeignKey(
Person, models.CASCADE, related_name="rel_to_set_2"
)
third = models.ForeignKey(
Person, models.CASCADE, related_name="too_many_by_far"
)
field = Person._meta.get_field("friends")
self.assertEqual(
field.check(from_model=Person),
[
Error(
"The model is used as an intermediate model by "
"'invalid_models_tests.Person.friends', but it has more than two "
"foreign keys to 'Person', which is ambiguous. You must specify "
"which two foreign keys Django should use via the through_fields "
"keyword argument.",
hint=(
"Use through_fields to specify which two foreign keys Django "
"should use."
),
obj=InvalidRelationship,
id="fields.E333",
),
],
)
def test_foreign_key_to_abstract_model(self):
class AbstractModel(models.Model):
class Meta:
abstract = True
class Model(models.Model):
rel_string_foreign_key = models.ForeignKey("AbstractModel", models.CASCADE)
rel_class_foreign_key = models.ForeignKey(AbstractModel, models.CASCADE)
fields = [
Model._meta.get_field("rel_string_foreign_key"),
Model._meta.get_field("rel_class_foreign_key"),
]
expected_error = Error(
"Field defines a relation with model 'AbstractModel', "
"which is either not installed, or is abstract.",
id="fields.E300",
)
for field in fields:
expected_error.obj = field
self.assertEqual(field.check(), [expected_error])
def test_m2m_to_abstract_model(self):
class AbstractModel(models.Model):
class Meta:
abstract = True
class Model(models.Model):
rel_string_m2m = models.ManyToManyField("AbstractModel")
rel_class_m2m = models.ManyToManyField(AbstractModel)
fields = [
Model._meta.get_field("rel_string_m2m"),
Model._meta.get_field("rel_class_m2m"),
]
expected_error = Error(
"Field defines a relation with model 'AbstractModel', "
"which is either not installed, or is abstract.",
id="fields.E300",
)
for field in fields:
expected_error.obj = field
self.assertEqual(field.check(from_model=Model), [expected_error])
def test_unique_m2m(self):
class Person(models.Model):
name = models.CharField(max_length=5)
class Group(models.Model):
members = models.ManyToManyField("Person", unique=True)
field = Group._meta.get_field("members")
self.assertEqual(
field.check(from_model=Group),
[
Error(
"ManyToManyFields cannot be unique.",
obj=field,
id="fields.E330",
),
],
)
def test_foreignkey_to_model_with_composite_primary_key(self):
class Parent(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Child(models.Model):
rel_class_parent = models.ForeignKey(
Parent, on_delete=models.CASCADE, related_name="child_class_set"
)
rel_string_parent = models.ForeignKey(
"Parent", on_delete=models.CASCADE, related_name="child_string_set"
)
error = (
"Field defines a relation involving model 'Parent' which has a "
"CompositePrimaryKey and such relations are not supported."
)
field = Child._meta.get_field("rel_string_parent")
self.assertEqual(
field.check(),
[Error(error, obj=field, id="fields.E347")],
)
field = Child._meta.get_field("rel_class_parent")
self.assertEqual(
field.check(),
[Error(error, obj=field, id="fields.E347")],
)
def test_many_to_many_to_model_with_composite_primary_key(self):
class Parent(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
class Child(models.Model):
rel_class_parent = models.ManyToManyField(
Parent, related_name="child_class_set"
)
rel_string_parent = models.ManyToManyField(
"Parent", related_name="child_string_set"
)
error = (
"Field defines a relation involving model 'Parent' which has a "
"CompositePrimaryKey and such relations are not supported."
)
field = Child._meta.get_field("rel_string_parent")
self.assertEqual(
field.check(from_model=Child),
[Error(error, obj=field, id="fields.E347")],
)
field = Child._meta.get_field("rel_class_parent")
self.assertEqual(
field.check(from_model=Child),
[Error(error, obj=field, id="fields.E347")],
)
def test_many_to_many_from_model_with_composite_primary_key(self):
class Parent(models.Model):
name = models.CharField(max_length=20)
class Meta:
app_label = "invalid_models_tests"
class Child(models.Model):
pk = models.CompositePrimaryKey("version", "name")
version = models.IntegerField()
name = models.CharField(max_length=20)
parents = models.ManyToManyField(Parent)
class Meta:
app_label = "invalid_models_tests"
error = (
"Field defines a relation involving model 'Child' which has a "
"CompositePrimaryKey and such relations are not supported."
)
field = Child._meta.get_field("parents")
self.assertEqual(
field.check(from_model=Child),
[Error(error, obj=field, id="fields.E347")],
)
def test_foreign_key_to_non_unique_field(self):
class Target(models.Model):
bad = models.IntegerField() # No unique=True
class Model(models.Model):
foreign_key = models.ForeignKey("Target", models.CASCADE, to_field="bad")
field = Model._meta.get_field("foreign_key")
self.assertEqual(
field.check(),
[
Error(
"'Target.bad' must be unique because it is referenced by a foreign "
"key.",
hint=(
"Add unique=True to this field or add a UniqueConstraint "
"(without condition) in the model Meta.constraints."
),
obj=field,
id="fields.E311",
),
],
)
def test_foreign_key_to_non_unique_field_under_explicit_model(self):
class Target(models.Model):
bad = models.IntegerField()
class Model(models.Model):
field = models.ForeignKey(Target, models.CASCADE, to_field="bad")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'Target.bad' must be unique because it is referenced by a foreign "
"key.",
hint=(
"Add unique=True to this field or add a UniqueConstraint "
"(without condition) in the model Meta.constraints."
),
obj=field,
id="fields.E311",
),
],
)
def test_foreign_key_to_partially_unique_field(self):
class Target(models.Model):
source = models.IntegerField()
class Meta:
constraints = [
models.UniqueConstraint(
fields=["source"],
name="tfktpuf_partial_unique",
condition=models.Q(pk__gt=2),
),
]
class Model(models.Model):
field = models.ForeignKey(Target, models.CASCADE, to_field="source")
field = Model._meta.get_field("field")
self.assertEqual(
field.check(),
[
Error(
"'Target.source' must be unique because it is referenced by a "
"foreign key.",
hint=(
"Add unique=True to this field or add a UniqueConstraint "
"(without condition) in the model Meta.constraints."
),
obj=field,
id="fields.E311",
),
],
)
def test_foreign_key_to_unique_field_with_meta_constraint(self):
class Target(models.Model):
source = models.IntegerField()
class Meta:
constraints = [
models.UniqueConstraint(
fields=["source"],
name="tfktufwmc_unique",
),
]
class Model(models.Model):
field = models.ForeignKey(Target, models.CASCADE, to_field="source")
field = Model._meta.get_field("field")
self.assertEqual(field.check(), [])
def test_foreign_object_to_non_unique_fields(self):
class Person(models.Model):
# Note that both fields are not unique.
country_id = models.IntegerField()
city_id = models.IntegerField()
class MMembership(models.Model):
person_country_id = models.IntegerField()
person_city_id = models.IntegerField()
person = models.ForeignObject(
Person,
on_delete=models.CASCADE,
from_fields=["person_country_id", "person_city_id"],
to_fields=["country_id", "city_id"],
)
field = MMembership._meta.get_field("person")
self.assertEqual(
field.check(),
[
Error(
"No subset of the fields 'country_id', 'city_id' on model 'Person' "
"is unique.",
hint=(
"Mark a single field as unique=True or add a set of "
"fields to a unique constraint (via unique_together or a "
"UniqueConstraint (without condition) in the model "
"Meta.constraints)."
),
obj=field,
id="fields.E310",
)
],
)
def test_foreign_object_to_partially_unique_field(self):
class Person(models.Model):
country_id = models.IntegerField()
city_id = models.IntegerField()
class Meta:
constraints = [
models.UniqueConstraint(
fields=["country_id", "city_id"],
name="tfotpuf_partial_unique",
condition=models.Q(pk__gt=2),
),
]
class MMembership(models.Model):
person_country_id = models.IntegerField()
person_city_id = models.IntegerField()
person = models.ForeignObject(
Person,
on_delete=models.CASCADE,
from_fields=["person_country_id", "person_city_id"],
to_fields=["country_id", "city_id"],
)
field = MMembership._meta.get_field("person")
self.assertEqual(
field.check(),
[
Error(
"No subset of the fields 'country_id', 'city_id' on model "
"'Person' is unique.",
hint=(
"Mark a single field as unique=True or add a set of "
"fields to a unique constraint (via unique_together or a "
"UniqueConstraint (without condition) in the model "
"Meta.constraints)."
),
obj=field,
id="fields.E310",
),
],
)
def test_foreign_object_to_unique_field_with_meta_constraint(self):
class Person(models.Model):
country_id = models.IntegerField()
city_id = models.IntegerField()
class Meta:
constraints = [
models.UniqueConstraint(
fields=["country_id", "city_id"],
name="tfotpuf_unique",
),
]
class MMembership(models.Model):
person_country_id = models.IntegerField()
person_city_id = models.IntegerField()
person = models.ForeignObject(
Person,
on_delete=models.CASCADE,
from_fields=["person_country_id", "person_city_id"],
to_fields=["country_id", "city_id"],
)
field = MMembership._meta.get_field("person")
self.assertEqual(field.check(), [])
def test_on_delete_set_null_on_non_nullable_field(self):
class Person(models.Model):
pass
class Model(models.Model):
foreign_key = models.ForeignKey("Person", models.SET_NULL)
field = Model._meta.get_field("foreign_key")
self.assertEqual(
field.check(),
[
Error(
"Field specifies on_delete=SET_NULL, but cannot be null.",
hint=(
"Set null=True argument on the field, or change the on_delete "
"rule."
),
obj=field,
id="fields.E320",
),
],
)
def test_on_delete_db_set_null_on_non_nullable_field(self):
class Person(models.Model):
pass
class Model(models.Model):
foreign_key = models.ForeignKey("Person", models.DB_SET_NULL)
field = Model._meta.get_field("foreign_key")
self.assertEqual(
field.check(),
[
Error(
"Field specifies on_delete=DB_SET_NULL, but cannot be null.",
hint=(
"Set null=True argument on the field, or change the on_delete "
"rule."
),
obj=field,
id="fields.E320",
),
],
)
def test_on_delete_set_default_without_default_value(self):
class Person(models.Model):
pass
class Model(models.Model):
foreign_key = models.ForeignKey("Person", models.SET_DEFAULT)
field = Model._meta.get_field("foreign_key")
self.assertEqual(
field.check(),
[
Error(
"Field specifies on_delete=SET_DEFAULT, but has no default value.",
hint="Set a default value, or change the on_delete rule.",
obj=field,
id="fields.E321",
),
],
)
def test_nullable_primary_key(self):
class Model(models.Model):
field = models.IntegerField(primary_key=True, null=True)
field = Model._meta.get_field("field")
with mock.patch.object(
connection.features, "interprets_empty_strings_as_nulls", False
):
results = field.check()
self.assertEqual(
results,
[
Error(
"Primary keys must not have null=True.",
hint=(
"Set null=False on the field, or remove primary_key=True "
"argument."
),
obj=field,
id="fields.E007",
),
],
)
def test_not_swapped_model(self):
class SwappableModel(models.Model):
# A model that can be, but isn't swapped out. References to this
# model should *not* raise any validation error.
class Meta:
swappable = "TEST_SWAPPABLE_MODEL"
class Model(models.Model):
explicit_fk = models.ForeignKey(
SwappableModel,
models.CASCADE,
related_name="explicit_fk",
)
implicit_fk = models.ForeignKey(
"invalid_models_tests.SwappableModel",
models.CASCADE,
related_name="implicit_fk",
)
explicit_m2m = models.ManyToManyField(
SwappableModel, related_name="explicit_m2m"
)
implicit_m2m = models.ManyToManyField(
"invalid_models_tests.SwappableModel",
related_name="implicit_m2m",
)
explicit_fk = Model._meta.get_field("explicit_fk")
self.assertEqual(explicit_fk.check(), [])
implicit_fk = Model._meta.get_field("implicit_fk")
self.assertEqual(implicit_fk.check(), [])
explicit_m2m = Model._meta.get_field("explicit_m2m")
self.assertEqual(explicit_m2m.check(from_model=Model), [])
implicit_m2m = Model._meta.get_field("implicit_m2m")
self.assertEqual(implicit_m2m.check(from_model=Model), [])
@override_settings(TEST_SWAPPED_MODEL="invalid_models_tests.Replacement")
def test_referencing_to_swapped_model(self):
class Replacement(models.Model):
pass
class SwappedModel(models.Model):
class Meta:
swappable = "TEST_SWAPPED_MODEL"
class Model(models.Model):
explicit_fk = models.ForeignKey(
SwappedModel,
models.CASCADE,
related_name="explicit_fk",
)
implicit_fk = models.ForeignKey(
"invalid_models_tests.SwappedModel",
models.CASCADE,
related_name="implicit_fk",
)
explicit_m2m = models.ManyToManyField(
SwappedModel, related_name="explicit_m2m"
)
implicit_m2m = models.ManyToManyField(
"invalid_models_tests.SwappedModel",
related_name="implicit_m2m",
)
fields = [
Model._meta.get_field("explicit_fk"),
Model._meta.get_field("implicit_fk"),
Model._meta.get_field("explicit_m2m"),
Model._meta.get_field("implicit_m2m"),
]
expected_error = Error(
(
"Field defines a relation with the model "
"'invalid_models_tests.SwappedModel', which has been swapped out."
),
hint="Update the relation to point at 'settings.TEST_SWAPPED_MODEL'.",
id="fields.E301",
)
for field in fields:
expected_error.obj = field
self.assertEqual(field.check(from_model=Model), [expected_error])
def test_related_field_has_invalid_related_name(self):
digit = 0
illegal_non_alphanumeric = "!"
whitespace = "\t"
invalid_related_names = [
"%s_begins_with_digit" % digit,
"%s_begins_with_illegal_non_alphanumeric" % illegal_non_alphanumeric,
"%s_begins_with_whitespace" % whitespace,
"contains_%s_illegal_non_alphanumeric" % illegal_non_alphanumeric,
"contains_%s_whitespace" % whitespace,
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/basic/models.py | tests/basic/models.py | import uuid
from django.db import models
class Article(models.Model):
headline = models.CharField(max_length=100, default="Default headline")
pub_date = models.DateTimeField()
class Meta:
ordering = ("pub_date", "headline")
def __str__(self):
return self.headline
class FeaturedArticle(models.Model):
article = models.OneToOneField(Article, models.CASCADE, related_name="featured")
class ArticleSelectOnSave(Article):
class Meta:
proxy = True
select_on_save = True
class SelfRef(models.Model):
selfref = models.ForeignKey(
"self",
models.SET_NULL,
null=True,
blank=True,
related_name="+",
)
article = models.ForeignKey(Article, models.SET_NULL, null=True, blank=True)
article_cited = models.ForeignKey(
Article, models.SET_NULL, null=True, blank=True, related_name="cited"
)
def __str__(self):
# This method intentionally doesn't work for all cases - part
# of the test for ticket #20278
return SelfRef.objects.get(selfref=self).pk
class PrimaryKeyWithDefault(models.Model):
uuid = models.UUIDField(primary_key=True, default=uuid.uuid4)
class PrimaryKeyWithDbDefault(models.Model):
uuid = models.IntegerField(primary_key=True, db_default=1)
class PrimaryKeyWithFalseyDefault(models.Model):
uuid = models.IntegerField(primary_key=True, default=0)
class PrimaryKeyWithFalseyDbDefault(models.Model):
uuid = models.IntegerField(primary_key=True, db_default=0)
class ChildPrimaryKeyWithDefault(PrimaryKeyWithDefault):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/basic/__init__.py | tests/basic/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/basic/tests.py | tests/basic/tests.py | import inspect
import threading
import time
from datetime import datetime, timedelta
from unittest import mock
from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist
from django.db import (
DEFAULT_DB_ALIAS,
DatabaseError,
connection,
connections,
models,
transaction,
)
from django.db.models.functions import Now
from django.db.models.manager import BaseManager
from django.db.models.query import MAX_GET_RESULTS, EmptyQuerySet
from django.test import (
SimpleTestCase,
TestCase,
TransactionTestCase,
skipUnlessDBFeature,
)
from django.test.utils import CaptureQueriesContext
from django.utils.connection import ConnectionDoesNotExist
from django.utils.translation import gettext_lazy
from .models import (
Article,
ArticleSelectOnSave,
ChildPrimaryKeyWithDefault,
FeaturedArticle,
PrimaryKeyWithDbDefault,
PrimaryKeyWithDefault,
PrimaryKeyWithFalseyDbDefault,
PrimaryKeyWithFalseyDefault,
SelfRef,
)
class ModelInstanceCreationTests(TestCase):
def test_object_is_not_written_to_database_until_save_was_called(self):
a = Article(
id=None,
headline="Parrot programs in Python",
pub_date=datetime(2005, 7, 28),
)
self.assertIsNone(a.id)
self.assertEqual(Article.objects.count(), 0)
# Save it into the database. You have to call save() explicitly.
a.save()
self.assertIsNotNone(a.id)
self.assertEqual(Article.objects.count(), 1)
def test_can_initialize_model_instance_using_positional_arguments(self):
"""
You can initialize a model instance using positional arguments,
which should match the field order as defined in the model.
"""
a = Article(None, "Second article", datetime(2005, 7, 29))
a.save()
self.assertEqual(a.headline, "Second article")
self.assertEqual(a.pub_date, datetime(2005, 7, 29, 0, 0))
def test_can_create_instance_using_kwargs(self):
a = Article(
id=None,
headline="Third article",
pub_date=datetime(2005, 7, 30),
)
a.save()
self.assertEqual(a.headline, "Third article")
self.assertEqual(a.pub_date, datetime(2005, 7, 30, 0, 0))
def test_autofields_generate_different_values_for_each_instance(self):
a1 = Article.objects.create(
headline="First", pub_date=datetime(2005, 7, 30, 0, 0)
)
a2 = Article.objects.create(
headline="First", pub_date=datetime(2005, 7, 30, 0, 0)
)
a3 = Article.objects.create(
headline="First", pub_date=datetime(2005, 7, 30, 0, 0)
)
self.assertNotEqual(a3.id, a1.id)
self.assertNotEqual(a3.id, a2.id)
def test_can_mix_and_match_position_and_kwargs(self):
# You can also mix and match position and keyword arguments, but
# be sure not to duplicate field information.
a = Article(None, "Fourth article", pub_date=datetime(2005, 7, 31))
a.save()
self.assertEqual(a.headline, "Fourth article")
def test_positional_and_keyword_args_for_the_same_field(self):
msg = "Article() got both positional and keyword arguments for field '%s'."
with self.assertRaisesMessage(TypeError, msg % "headline"):
Article(None, "Fifth article", headline="Other headline.")
with self.assertRaisesMessage(TypeError, msg % "headline"):
Article(None, "Sixth article", headline="")
with self.assertRaisesMessage(TypeError, msg % "pub_date"):
Article(None, "Seventh article", datetime(2021, 3, 1), pub_date=None)
def test_cannot_create_instance_with_invalid_kwargs(self):
msg = "Article() got unexpected keyword arguments: 'foo'"
with self.assertRaisesMessage(TypeError, msg):
Article(
id=None,
headline="Some headline",
pub_date=datetime(2005, 7, 31),
foo="bar",
)
msg = "Article() got unexpected keyword arguments: 'foo', 'bar'"
with self.assertRaisesMessage(TypeError, msg):
Article(
id=None,
headline="Some headline",
pub_date=datetime(2005, 7, 31),
foo="bar",
bar="baz",
)
def test_can_leave_off_value_for_autofield_and_it_gets_value_on_save(self):
"""
You can leave off the value for an AutoField when creating an
object, because it'll get filled in automatically when you save().
"""
a = Article(headline="Article 5", pub_date=datetime(2005, 7, 31))
a.save()
self.assertEqual(a.headline, "Article 5")
self.assertIsNotNone(a.id)
def test_leaving_off_a_field_with_default_set_the_default_will_be_saved(self):
a = Article(pub_date=datetime(2005, 7, 31))
a.save()
self.assertEqual(a.headline, "Default headline")
def test_for_datetimefields_saves_as_much_precision_as_was_given(self):
"""as much precision in *seconds*"""
a1 = Article(
headline="Article 7",
pub_date=datetime(2005, 7, 31, 12, 30),
)
a1.save()
self.assertEqual(
Article.objects.get(id__exact=a1.id).pub_date, datetime(2005, 7, 31, 12, 30)
)
a2 = Article(
headline="Article 8",
pub_date=datetime(2005, 7, 31, 12, 30, 45),
)
a2.save()
self.assertEqual(
Article.objects.get(id__exact=a2.id).pub_date,
datetime(2005, 7, 31, 12, 30, 45),
)
def test_saving_an_object_again_does_not_create_a_new_object(self):
a = Article(headline="original", pub_date=datetime(2014, 5, 16))
a.save()
current_id = a.id
a.save()
self.assertEqual(a.id, current_id)
a.headline = "Updated headline"
a.save()
self.assertEqual(a.id, current_id)
def test_querysets_checking_for_membership(self):
headlines = ["Parrot programs in Python", "Second article", "Third article"]
some_pub_date = datetime(2014, 5, 16, 12, 1)
for headline in headlines:
Article(headline=headline, pub_date=some_pub_date).save()
a = Article(headline="Some headline", pub_date=some_pub_date)
a.save()
# You can use 'in' to test for membership...
self.assertIn(a, Article.objects.all())
# ... but there will often be more efficient ways if that is all you
# need:
self.assertTrue(Article.objects.filter(id=a.id).exists())
def test_save_primary_with_default(self):
# An UPDATE attempt is skipped when a primary key has default.
with self.assertNumQueries(1):
PrimaryKeyWithDefault().save()
def test_save_primary_with_default_force_update(self):
# An UPDATE attempt is made if explicitly requested.
obj = PrimaryKeyWithDefault.objects.create()
with self.assertNumQueries(1):
PrimaryKeyWithDefault(uuid=obj.pk).save(force_update=True)
def test_save_primary_with_db_default(self):
# An UPDATE attempt is skipped when a primary key has db_default.
with self.assertNumQueries(1):
PrimaryKeyWithDbDefault().save()
def test_save_parent_primary_with_default(self):
# An UPDATE attempt is skipped when an inherited primary key has
# default.
with self.assertNumQueries(2):
ChildPrimaryKeyWithDefault().save()
def test_save_primary_with_falsey_default(self):
with self.assertNumQueries(1):
PrimaryKeyWithFalseyDefault().save()
def test_save_primary_with_falsey_db_default(self):
with self.assertNumQueries(1):
PrimaryKeyWithFalseyDbDefault().save()
def test_auto_field_with_value_refreshed(self):
"""
An auto field must be refreshed by Model.save() even when a value is
set because the database may return a value of a different type.
"""
a = Article.objects.create(pk="123456", pub_date=datetime(2025, 9, 16))
self.assertEqual(a.pk, 123456)
class ModelTest(TestCase):
def test_objects_attribute_is_only_available_on_the_class_itself(self):
with self.assertRaisesMessage(
AttributeError, "Manager isn't accessible via Article instances"
):
getattr(
Article(),
"objects",
)
self.assertFalse(hasattr(Article(), "objects"))
self.assertTrue(hasattr(Article, "objects"))
def test_queryset_delete_removes_all_items_in_that_queryset(self):
headlines = ["An article", "Article One", "Amazing article", "Boring article"]
some_pub_date = datetime(2014, 5, 16, 12, 1)
for headline in headlines:
Article(headline=headline, pub_date=some_pub_date).save()
self.assertQuerySetEqual(
Article.objects.order_by("headline"),
sorted(headlines),
transform=lambda a: a.headline,
)
Article.objects.filter(headline__startswith="A").delete()
self.assertEqual(Article.objects.get().headline, "Boring article")
def test_not_equal_and_equal_operators_behave_as_expected_on_instances(self):
some_pub_date = datetime(2014, 5, 16, 12, 1)
a1 = Article.objects.create(headline="First", pub_date=some_pub_date)
a2 = Article.objects.create(headline="Second", pub_date=some_pub_date)
self.assertNotEqual(a1, a2)
self.assertEqual(a1, Article.objects.get(id__exact=a1.id))
self.assertNotEqual(
Article.objects.get(id__exact=a1.id), Article.objects.get(id__exact=a2.id)
)
def test_microsecond_precision(self):
a9 = Article(
headline="Article 9",
pub_date=datetime(2005, 7, 31, 12, 30, 45, 180),
)
a9.save()
self.assertEqual(
Article.objects.get(pk=a9.pk).pub_date,
datetime(2005, 7, 31, 12, 30, 45, 180),
)
def test_manually_specify_primary_key(self):
# You can manually specify the primary key when creating a new object.
a101 = Article(
id=101,
headline="Article 101",
pub_date=datetime(2005, 7, 31, 12, 30, 45),
)
a101.save()
a101 = Article.objects.get(pk=101)
self.assertEqual(a101.headline, "Article 101")
def test_create_method(self):
# You can create saved objects in a single step
a10 = Article.objects.create(
headline="Article 10",
pub_date=datetime(2005, 7, 31, 12, 30, 45),
)
self.assertEqual(Article.objects.get(headline="Article 10"), a10)
def test_create_method_propagates_fetch_mode(self):
article = Article.objects.fetch_mode(models.FETCH_PEERS).create(
headline="Article 10",
pub_date=datetime(2005, 7, 31, 12, 30, 45),
)
self.assertEqual(article._state.fetch_mode, models.FETCH_PEERS)
def test_year_lookup_edge_case(self):
# Edge-case test: A year lookup should retrieve all objects in
# the given year, including Jan. 1 and Dec. 31.
a11 = Article.objects.create(
headline="Article 11",
pub_date=datetime(2008, 1, 1),
)
a12 = Article.objects.create(
headline="Article 12",
pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999),
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__year=2008),
[a11, a12],
)
def test_unicode_data(self):
# Unicode data works, too.
a = Article(
headline="\u6797\u539f \u3081\u3050\u307f",
pub_date=datetime(2005, 7, 28),
)
a.save()
self.assertEqual(
Article.objects.get(pk=a.id).headline, "\u6797\u539f \u3081\u3050\u307f"
)
def test_hash_function(self):
# Model instances have a hash function, so they can be used in sets
# or as dictionary keys. Two models compare as equal if their primary
# keys are equal.
a10 = Article.objects.create(
headline="Article 10",
pub_date=datetime(2005, 7, 31, 12, 30, 45),
)
a11 = Article.objects.create(
headline="Article 11",
pub_date=datetime(2008, 1, 1),
)
a12 = Article.objects.create(
headline="Article 12",
pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999),
)
s = {a10, a11, a12}
self.assertIn(Article.objects.get(headline="Article 11"), s)
def test_extra_method_select_argument_with_dashes_and_values(self):
# The 'select' argument to extra() supports names with dashes in
# them, as long as you use values().
Article.objects.bulk_create(
[
Article(
headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45)
),
Article(headline="Article 11", pub_date=datetime(2008, 1, 1)),
Article(
headline="Article 12",
pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999),
),
]
)
dicts = (
Article.objects.filter(pub_date__year=2008)
.extra(select={"dashed-value": "1"})
.values("headline", "dashed-value")
)
self.assertEqual(
[sorted(d.items()) for d in dicts],
[
[("dashed-value", 1), ("headline", "Article 11")],
[("dashed-value", 1), ("headline", "Article 12")],
],
)
def test_extra_method_select_argument_with_dashes(self):
# If you use 'select' with extra() and names containing dashes on a
# query that's *not* a values() query, those extra 'select' values
# will silently be ignored.
Article.objects.bulk_create(
[
Article(
headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45)
),
Article(headline="Article 11", pub_date=datetime(2008, 1, 1)),
Article(
headline="Article 12",
pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999),
),
]
)
articles = Article.objects.filter(pub_date__year=2008).extra(
select={"dashed-value": "1", "undashedvalue": "2"}
)
self.assertEqual(articles[0].undashedvalue, 2)
def test_create_relation_with_gettext_lazy(self):
"""
gettext_lazy objects work when saving model instances
through various methods. Refs #10498.
"""
notlazy = "test"
lazy = gettext_lazy(notlazy)
Article.objects.create(headline=lazy, pub_date=datetime.now())
article = Article.objects.get()
self.assertEqual(article.headline, notlazy)
# test that assign + save works with Promise objects
article.headline = lazy
article.save()
self.assertEqual(article.headline, notlazy)
# test .update()
Article.objects.update(headline=lazy)
article = Article.objects.get()
self.assertEqual(article.headline, notlazy)
# still test bulk_create()
Article.objects.all().delete()
Article.objects.bulk_create([Article(headline=lazy, pub_date=datetime.now())])
article = Article.objects.get()
self.assertEqual(article.headline, notlazy)
def test_emptyqs(self):
msg = "EmptyQuerySet can't be instantiated"
with self.assertRaisesMessage(TypeError, msg):
EmptyQuerySet()
self.assertIsInstance(Article.objects.none(), EmptyQuerySet)
self.assertNotIsInstance("", EmptyQuerySet)
def test_emptyqs_values(self):
# test for #15959
Article.objects.create(headline="foo", pub_date=datetime.now())
with self.assertNumQueries(0):
qs = Article.objects.none().values_list("pk")
self.assertIsInstance(qs, EmptyQuerySet)
self.assertEqual(len(qs), 0)
def test_emptyqs_customqs(self):
# A hacky test for custom QuerySet subclass - refs #17271
Article.objects.create(headline="foo", pub_date=datetime.now())
class CustomQuerySet(models.QuerySet):
def do_something(self):
return "did something"
qs = Article.objects.all()
qs.__class__ = CustomQuerySet
qs = qs.none()
with self.assertNumQueries(0):
self.assertEqual(len(qs), 0)
self.assertIsInstance(qs, EmptyQuerySet)
self.assertEqual(qs.do_something(), "did something")
def test_emptyqs_values_order(self):
# Tests for ticket #17712
Article.objects.create(headline="foo", pub_date=datetime.now())
with self.assertNumQueries(0):
self.assertEqual(
len(Article.objects.none().values_list("id").order_by("id")), 0
)
with self.assertNumQueries(0):
self.assertEqual(
len(
Article.objects.none().filter(
id__in=Article.objects.values_list("id", flat=True)
)
),
0,
)
@skipUnlessDBFeature("can_distinct_on_fields")
def test_emptyqs_distinct(self):
# Tests for #19426
Article.objects.create(headline="foo", pub_date=datetime.now())
with self.assertNumQueries(0):
self.assertEqual(
len(Article.objects.none().distinct("headline", "pub_date")), 0
)
def test_ticket_20278(self):
sr = SelfRef.objects.create()
with self.assertRaises(ObjectDoesNotExist):
SelfRef.objects.get(selfref=sr)
def test_eq(self):
self.assertEqual(Article(id=1), Article(id=1))
self.assertNotEqual(Article(id=1), object())
self.assertNotEqual(object(), Article(id=1))
a = Article()
self.assertEqual(a, a)
self.assertEqual(a, mock.ANY)
self.assertNotEqual(Article(), a)
def test_hash(self):
# Value based on PK
self.assertEqual(hash(Article(id=1)), hash(1))
msg = "Model instances without primary key value are unhashable"
with self.assertRaisesMessage(TypeError, msg):
# No PK value -> unhashable (because save() would then change
# hash)
hash(Article())
def test_missing_hash_not_inherited(self):
class NoHash(models.Model):
def __eq__(self, other):
return super.__eq__(other)
with self.assertRaisesMessage(TypeError, "unhashable type: 'NoHash'"):
hash(NoHash(id=1))
def test_specified_parent_hash_inherited(self):
class ParentHash(models.Model):
def __eq__(self, other):
return super.__eq__(other)
__hash__ = models.Model.__hash__
self.assertEqual(hash(ParentHash(id=1)), 1)
def test_delete_and_access_field(self):
# Accessing a field after it's deleted from a model reloads its value.
pub_date = datetime.now()
article = Article.objects.create(headline="foo", pub_date=pub_date)
new_pub_date = article.pub_date + timedelta(days=10)
article.headline = "bar"
article.pub_date = new_pub_date
del article.headline
with self.assertNumQueries(1):
self.assertEqual(article.headline, "foo")
# Fields that weren't deleted aren't reloaded.
self.assertEqual(article.pub_date, new_pub_date)
def test_multiple_objects_max_num_fetched(self):
max_results = MAX_GET_RESULTS - 1
Article.objects.bulk_create(
Article(headline="Area %s" % i, pub_date=datetime(2005, 7, 28))
for i in range(max_results)
)
self.assertRaisesMessage(
MultipleObjectsReturned,
"get() returned more than one Article -- it returned %d!" % max_results,
Article.objects.get,
headline__startswith="Area",
)
Article.objects.create(
headline="Area %s" % max_results, pub_date=datetime(2005, 7, 28)
)
self.assertRaisesMessage(
MultipleObjectsReturned,
"get() returned more than one Article -- it returned more than %d!"
% max_results,
Article.objects.get,
headline__startswith="Area",
)
def test_is_pk_unset(self):
cases = [
Article(),
Article(id=None),
]
for case in cases:
with self.subTest(case=case):
self.assertIs(case._is_pk_set(), False)
def test_is_pk_set(self):
def new_instance():
a = Article(pub_date=datetime.today())
a.save()
return a
cases = [
Article(id=1),
Article(id=0),
Article.objects.create(pub_date=datetime.today()),
new_instance(),
]
for case in cases:
with self.subTest(case=case):
self.assertIs(case._is_pk_set(), True)
def test_save_expressions(self):
article = Article(pub_date=Now())
article.save()
expected_num_queries = (
0 if connection.features.can_return_columns_from_insert else 1
)
with self.assertNumQueries(expected_num_queries):
article_pub_date = article.pub_date
self.assertIsInstance(article_pub_date, datetime)
# Sleep slightly to ensure a different database level NOW().
time.sleep(0.1)
article.pub_date = Now()
article.save()
expected_num_queries = (
0 if connection.features.can_return_rows_from_update else 1
)
with self.assertNumQueries(expected_num_queries):
self.assertIsInstance(article.pub_date, datetime)
self.assertGreater(article.pub_date, article_pub_date)
class ModelLookupTest(TestCase):
@classmethod
def setUpTestData(cls):
# Create an Article.
cls.a = Article(
id=None,
headline="Swallow programs in Python",
pub_date=datetime(2005, 7, 28),
)
# Save it into the database. You have to call save() explicitly.
cls.a.save()
def test_all_lookup(self):
# Change values by changing the attributes, then calling save().
self.a.headline = "Parrot programs in Python"
self.a.save()
# Article.objects.all() returns all the articles in the database.
self.assertSequenceEqual(Article.objects.all(), [self.a])
def test_rich_lookup(self):
# Django provides a rich database lookup API.
self.assertEqual(Article.objects.get(id__exact=self.a.id), self.a)
self.assertEqual(Article.objects.get(headline__startswith="Swallow"), self.a)
self.assertEqual(Article.objects.get(pub_date__year=2005), self.a)
self.assertEqual(
Article.objects.get(pub_date__year=2005, pub_date__month=7), self.a
)
self.assertEqual(
Article.objects.get(
pub_date__year=2005, pub_date__month=7, pub_date__day=28
),
self.a,
)
self.assertEqual(Article.objects.get(pub_date__week_day=5), self.a)
def test_equal_lookup(self):
# The "__exact" lookup type can be omitted, as a shortcut.
self.assertEqual(Article.objects.get(id=self.a.id), self.a)
self.assertEqual(
Article.objects.get(headline="Swallow programs in Python"), self.a
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__year=2005),
[self.a],
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__year=2004),
[],
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__year=2005, pub_date__month=7),
[self.a],
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__week_day=5),
[self.a],
)
self.assertSequenceEqual(
Article.objects.filter(pub_date__week_day=6),
[],
)
def test_does_not_exist(self):
# Django raises an Article.DoesNotExist exception for get() if the
# parameters don't match any object.
with self.assertRaisesMessage(
ObjectDoesNotExist, "Article matching query does not exist."
):
Article.objects.get(
id__exact=2000,
)
# To avoid dict-ordering related errors check only one lookup
# in single assert.
with self.assertRaises(ObjectDoesNotExist):
Article.objects.get(pub_date__year=2005, pub_date__month=8)
with self.assertRaisesMessage(
ObjectDoesNotExist, "Article matching query does not exist."
):
Article.objects.get(
pub_date__week_day=6,
)
def test_lookup_by_primary_key(self):
# Lookup by a primary key is the most common case, so Django
# provides a shortcut for primary-key exact lookups.
# The following is identical to articles.get(id=a.id).
self.assertEqual(Article.objects.get(pk=self.a.id), self.a)
# pk can be used as a shortcut for the primary key name in any query.
self.assertSequenceEqual(Article.objects.filter(pk__in=[self.a.id]), [self.a])
# Model instances of the same type and same ID are considered equal.
a = Article.objects.get(pk=self.a.id)
b = Article.objects.get(pk=self.a.id)
self.assertEqual(a, b)
def test_too_many(self):
# Create a very similar object
a = Article(
id=None,
headline="Swallow bites Python",
pub_date=datetime(2005, 7, 28),
)
a.save()
self.assertEqual(Article.objects.count(), 2)
# Django raises an Article.MultipleObjectsReturned exception if the
# lookup matches more than one object
msg = "get() returned more than one Article -- it returned 2!"
with self.assertRaisesMessage(MultipleObjectsReturned, msg):
Article.objects.get(
headline__startswith="Swallow",
)
with self.assertRaisesMessage(MultipleObjectsReturned, msg):
Article.objects.get(
pub_date__year=2005,
)
with self.assertRaisesMessage(MultipleObjectsReturned, msg):
Article.objects.get(pub_date__year=2005, pub_date__month=7)
class ConcurrentSaveTests(TransactionTestCase):
available_apps = ["basic"]
@skipUnlessDBFeature("test_db_allows_multiple_connections")
def test_concurrent_delete_with_save(self):
"""
Test fetching, deleting and finally saving an object - we should get
an insert in this case.
"""
a = Article.objects.create(headline="foo", pub_date=datetime.now())
exceptions = []
def deleter():
try:
# Do not delete a directly - doing so alters its state.
Article.objects.filter(pk=a.pk).delete()
except Exception as e:
exceptions.append(e)
finally:
connections[DEFAULT_DB_ALIAS].close()
self.assertEqual(len(exceptions), 0)
t = threading.Thread(target=deleter)
t.start()
t.join()
a.save()
self.assertEqual(Article.objects.get(pk=a.pk).headline, "foo")
class ManagerTest(SimpleTestCase):
QUERYSET_PROXY_METHODS = [
"none",
"count",
"dates",
"datetimes",
"distinct",
"extra",
"get",
"get_or_create",
"update_or_create",
"create",
"bulk_create",
"bulk_update",
"filter",
"aggregate",
"annotate",
"alias",
"complex_filter",
"exclude",
"in_bulk",
"iterator",
"earliest",
"latest",
"first",
"last",
"order_by",
"select_for_update",
"select_related",
"prefetch_related",
"values",
"values_list",
"update",
"reverse",
"defer",
"only",
"using",
"exists",
"contains",
"explain",
"_insert",
"_update",
"raw",
"union",
"intersection",
"difference",
"aaggregate",
"abulk_create",
"abulk_update",
"acontains",
"acount",
"acreate",
"aearliest",
"aexists",
"aexplain",
"afirst",
"aget",
"aget_or_create",
"ain_bulk",
"aiterator",
"alast",
"alatest",
"aupdate",
"aupdate_or_create",
"fetch_mode",
]
def test_manager_methods(self):
"""
This test ensures that the correct set of methods from `QuerySet`
are copied onto `Manager`.
It's particularly useful to prevent accidentally leaking new methods
into `Manager`. New `QuerySet` methods that should also be copied onto
`Manager` will need to be added to
`ManagerTest.QUERYSET_PROXY_METHODS`.
"""
self.assertEqual(
sorted(BaseManager._get_queryset_methods(models.QuerySet)),
sorted(self.QUERYSET_PROXY_METHODS),
)
def test_manager_method_attributes(self):
self.assertEqual(Article.objects.get.__doc__, models.QuerySet.get.__doc__)
self.assertEqual(Article.objects.count.__name__, models.QuerySet.count.__name__)
def test_manager_method_signature(self):
self.assertEqual(
str(inspect.signature(Article.objects.bulk_create)),
"(objs, batch_size=None, ignore_conflicts=False, update_conflicts=False, "
"update_fields=None, unique_fields=None)",
)
class SelectOnSaveTests(TestCase):
def test_select_on_save(self):
a1 = Article.objects.create(pub_date=datetime.now())
with self.assertNumQueries(1):
a1.save()
asos = ArticleSelectOnSave.objects.create(pub_date=datetime.now())
with self.assertNumQueries(2):
asos.save()
with self.assertNumQueries(1):
asos.save(force_update=True)
Article.objects.all().delete()
with self.assertRaisesMessage(
DatabaseError, "Forced update did not affect any rows."
):
with self.assertNumQueries(1):
asos.save(force_update=True)
def test_select_on_save_lying_update(self):
"""
select_on_save works correctly if the database doesn't return correct
information about matched rows from UPDATE.
"""
# Change the manager to not return "row matched" for update().
# We are going to change the Article's _base_manager class
# dynamically. This is a bit of a hack, but it seems hard to
# test this properly otherwise. Article's manager, because
# proxy models use their parent model's _base_manager.
orig_class = Article._base_manager._queryset_class
class FakeQuerySet(models.QuerySet):
# Make sure the _update method below is in fact called.
called = False
def _update(self, *args, **kwargs):
FakeQuerySet.called = True
super()._update(*args, **kwargs)
return 0
try:
Article._base_manager._queryset_class = FakeQuerySet
asos = ArticleSelectOnSave.objects.create(pub_date=datetime.now())
with self.assertNumQueries(3):
asos.save()
self.assertTrue(FakeQuerySet.called)
# This is not wanted behavior, but this is how Django has always
# behaved for databases that do not return correct information
# about matched rows for UPDATE.
with self.assertRaisesMessage(
DatabaseError, "Forced update did not affect any rows."
):
asos.save(force_update=True)
msg = (
"An error occurred in the current transaction. You can't "
"execute queries until the end of the 'atomic' block."
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/string_lookup/models.py | tests/string_lookup/models.py | from django.db import models
class Foo(models.Model):
name = models.CharField(max_length=50)
friend = models.CharField(max_length=50, blank=True)
class Bar(models.Model):
name = models.CharField(max_length=50)
normal = models.ForeignKey(Foo, models.CASCADE, related_name="normal_foo")
fwd = models.ForeignKey("Whiz", models.CASCADE)
back = models.ForeignKey("Foo", models.CASCADE)
class Whiz(models.Model):
name = models.CharField(max_length=50)
class Child(models.Model):
parent = models.OneToOneField("Base", models.CASCADE)
name = models.CharField(max_length=50)
class Base(models.Model):
name = models.CharField(max_length=50)
class Article(models.Model):
name = models.CharField(max_length=50)
text = models.TextField()
submitted_from = models.GenericIPAddressField(blank=True, null=True)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/string_lookup/__init__.py | tests/string_lookup/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.