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/empty_models/__init__.py | tests/empty_models/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/empty_models/test_commands.py | tests/empty_models/test_commands.py | import io
from django.core.management import call_command
from django.test import TestCase
class CoreCommandsNoOutputTests(TestCase):
available_apps = ["empty_models"]
def test_sqlflush_no_tables(self):
out = io.StringIO()
err = io.StringIO()
call_command("sqlflush", stdout=out, stderr=err)
self.assertEqual(out.getvalue(), "")
self.assertEqual(err.getvalue(), "No tables found.\n")
def test_sqlsequencereset_no_sequences(self):
out = io.StringIO()
err = io.StringIO()
call_command("sqlsequencereset", "empty_models", stdout=out, stderr=err)
self.assertEqual(out.getvalue(), "")
self.assertEqual(err.getvalue(), "No sequences found.\n")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sites_framework/models.py | tests/sites_framework/models.py | from django.contrib.sites.managers import CurrentSiteManager
from django.contrib.sites.models import Site
from django.db import models
class AbstractArticle(models.Model):
title = models.CharField(max_length=50)
objects = models.Manager()
on_site = CurrentSiteManager()
class Meta:
abstract = True
class SyndicatedArticle(AbstractArticle):
sites = models.ManyToManyField(Site)
class ExclusiveArticle(AbstractArticle):
site = models.ForeignKey(Site, models.CASCADE)
class CustomArticle(AbstractArticle):
places_this_article_should_appear = models.ForeignKey(Site, models.CASCADE)
objects = models.Manager()
on_site = CurrentSiteManager("places_this_article_should_appear")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sites_framework/__init__.py | tests/sites_framework/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sites_framework/tests.py | tests/sites_framework/tests.py | from django.conf import settings
from django.contrib.sites.managers import CurrentSiteManager
from django.contrib.sites.models import Site
from django.core import checks
from django.db import models
from django.test import SimpleTestCase, TestCase
from django.test.utils import isolate_apps
from .models import CustomArticle, ExclusiveArticle, SyndicatedArticle
class SitesFrameworkTestCase(TestCase):
@classmethod
def setUpTestData(cls):
Site.objects.get_or_create(
id=settings.SITE_ID, domain="example.com", name="example.com"
)
Site.objects.create(
id=settings.SITE_ID + 1, domain="example2.com", name="example2.com"
)
def test_site_fk(self):
article = ExclusiveArticle.objects.create(
title="Breaking News!", site_id=settings.SITE_ID
)
self.assertEqual(ExclusiveArticle.on_site.get(), article)
def test_sites_m2m(self):
article = SyndicatedArticle.objects.create(title="Fresh News!")
article.sites.add(Site.objects.get(id=settings.SITE_ID))
article.sites.add(Site.objects.get(id=settings.SITE_ID + 1))
article2 = SyndicatedArticle.objects.create(title="More News!")
article2.sites.add(Site.objects.get(id=settings.SITE_ID + 1))
self.assertEqual(SyndicatedArticle.on_site.get(), article)
def test_custom_named_field(self):
article = CustomArticle.objects.create(
title="Tantalizing News!",
places_this_article_should_appear_id=settings.SITE_ID,
)
self.assertEqual(CustomArticle.on_site.get(), article)
@isolate_apps("sites_framework")
class CurrentSiteManagerChecksTests(SimpleTestCase):
def test_invalid_name(self):
class InvalidArticle(models.Model):
on_site = CurrentSiteManager("places_this_article_should_appear")
errors = InvalidArticle.check()
expected = [
checks.Error(
"CurrentSiteManager could not find a field named "
"'places_this_article_should_appear'.",
obj=InvalidArticle.on_site,
id="sites.E001",
)
]
self.assertEqual(errors, expected)
def test_invalid_field_type(self):
class ConfusedArticle(models.Model):
site = models.IntegerField()
on_site = CurrentSiteManager()
errors = ConfusedArticle.check()
expected = [
checks.Error(
"CurrentSiteManager cannot use 'ConfusedArticle.site' as it is "
"not a foreign key or a many-to-many field.",
obj=ConfusedArticle.on_site,
id="sites.E002",
)
]
self.assertEqual(errors, expected)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sites_framework/migrations/0001_initial.py | tests/sites_framework/migrations/0001_initial.py | from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("sites", "0001_initial"),
]
operations = [
migrations.CreateModel(
name="CustomArticle",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=50)),
(
"places_this_article_should_appear",
models.ForeignKey("sites.Site", models.CASCADE),
),
],
options={
"abstract": False,
},
bases=(models.Model,),
),
migrations.CreateModel(
name="ExclusiveArticle",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=50)),
("site", models.ForeignKey("sites.Site", models.CASCADE)),
],
options={
"abstract": False,
},
bases=(models.Model,),
),
migrations.CreateModel(
name="SyndicatedArticle",
fields=[
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("title", models.CharField(max_length=50)),
("sites", models.ManyToManyField("sites.Site")),
],
options={
"abstract": False,
},
bases=(models.Model,),
),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sites_framework/migrations/__init__.py | tests/sites_framework/migrations/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/import_error_package/__init__.py | tests/import_error_package/__init__.py | # A package that raises an ImportError that can be shared among test apps and
# excluded from test discovery.
raise ImportError("Oops")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/test_jinja2.py | tests/template_backends/test_jinja2.py | from pathlib import Path
from unittest import mock, skipIf
from django.contrib.auth.models import User
from django.template import TemplateSyntaxError
from django.test import RequestFactory, TestCase
from .test_dummy import TemplateStringsTests
try:
import jinja2
except ImportError:
jinja2 = None
Jinja2 = None
else:
from django.template.backends.jinja2 import Jinja2
@skipIf(jinja2 is None, "this test requires jinja2")
class Jinja2Tests(TemplateStringsTests):
engine_class = Jinja2
backend_name = "jinja2"
options = {
"keep_trailing_newline": True,
"context_processors": [
"django.template.context_processors.static",
],
}
def test_origin(self):
template = self.engine.get_template("template_backends/hello.html")
self.assertTrue(template.origin.name.endswith("hello.html"))
self.assertEqual(template.origin.template_name, "template_backends/hello.html")
def test_origin_from_string(self):
template = self.engine.from_string("Hello!\n")
self.assertEqual(template.origin.name, "<template>")
self.assertIsNone(template.origin.template_name)
def test_self_context(self):
"""
Using 'self' in the context should not throw errors (#24538).
"""
# self will be overridden to be a TemplateReference, so the self
# variable will not come through. Attempting to use one though should
# not throw an error.
template = self.engine.from_string("hello {{ foo }}!")
content = template.render(context={"self": "self", "foo": "world"})
self.assertEqual(content, "hello world!")
def test_exception_debug_info_min_context(self):
with self.assertRaises(TemplateSyntaxError) as e:
self.engine.get_template("template_backends/syntax_error.html")
debug = e.exception.template_debug
self.assertEqual(debug["after"], "")
self.assertEqual(debug["before"], "")
self.assertEqual(debug["during"], "{% block %}")
self.assertEqual(debug["bottom"], 1)
self.assertEqual(debug["top"], 0)
self.assertEqual(debug["line"], 1)
self.assertEqual(debug["total"], 1)
self.assertEqual(len(debug["source_lines"]), 1)
self.assertTrue(debug["name"].endswith("syntax_error.html"))
self.assertIn("message", debug)
def test_exception_debug_info_max_context(self):
with self.assertRaises(TemplateSyntaxError) as e:
self.engine.get_template("template_backends/syntax_error2.html")
debug = e.exception.template_debug
self.assertEqual(debug["after"], "")
self.assertEqual(debug["before"], "")
self.assertEqual(debug["during"], "{% block %}")
self.assertEqual(debug["bottom"], 26)
self.assertEqual(debug["top"], 5)
self.assertEqual(debug["line"], 16)
self.assertEqual(debug["total"], 31)
self.assertEqual(len(debug["source_lines"]), 21)
self.assertTrue(debug["name"].endswith("syntax_error2.html"))
self.assertIn("message", debug)
def test_context_processors(self):
request = RequestFactory().get("/")
template = self.engine.from_string("Static URL: {{ STATIC_URL }}")
content = template.render(request=request)
self.assertEqual(content, "Static URL: /static/")
with self.settings(STATIC_URL="/s/"):
content = template.render(request=request)
self.assertEqual(content, "Static URL: /s/")
def test_dirs_pathlib(self):
engine = Jinja2(
{
"DIRS": [Path(__file__).parent / "templates" / "template_backends"],
"APP_DIRS": False,
"NAME": "jinja2",
"OPTIONS": {},
}
)
template = engine.get_template("hello.html")
self.assertEqual(template.render({"name": "Joe"}), "Hello Joe!")
def test_template_render_nested_error(self):
template = self.engine.get_template(
"template_backends/syntax_error_include.html"
)
with self.assertRaises(TemplateSyntaxError) as e:
template.render(context={})
debug = e.exception.template_debug
self.assertEqual(debug["after"], "")
self.assertEqual(debug["before"], "")
self.assertEqual(debug["during"], "{% block %}")
self.assertEqual(debug["bottom"], 1)
self.assertEqual(debug["top"], 0)
self.assertEqual(debug["line"], 1)
self.assertEqual(debug["total"], 1)
self.assertEqual(len(debug["source_lines"]), 1)
self.assertTrue(debug["name"].endswith("syntax_error.html"))
self.assertIn("message", debug)
def test_template_render_error_nonexistent_source(self):
template = self.engine.get_template("template_backends/hello.html")
with mock.patch(
"jinja2.environment.Template.render",
side_effect=jinja2.TemplateSyntaxError("", 1, filename="nonexistent.html"),
):
with self.assertRaises(TemplateSyntaxError) as e:
template.render(context={})
debug = e.exception.template_debug
self.assertEqual(debug["after"], "")
self.assertEqual(debug["before"], "")
self.assertEqual(debug["during"], "")
self.assertEqual(debug["bottom"], 0)
self.assertEqual(debug["top"], 0)
self.assertEqual(debug["line"], 1)
self.assertEqual(debug["total"], 0)
self.assertEqual(len(debug["source_lines"]), 0)
self.assertTrue(debug["name"].endswith("nonexistent.html"))
self.assertIn("message", debug)
@skipIf(jinja2 is None, "this test requires jinja2")
class Jinja2SandboxTests(TestCase):
engine_class = Jinja2
backend_name = "jinja2"
options = {"environment": "jinja2.sandbox.SandboxedEnvironment"}
@classmethod
def setUpClass(cls):
super().setUpClass()
params = {
"DIRS": [],
"APP_DIRS": True,
"NAME": cls.backend_name,
"OPTIONS": cls.options,
}
cls.engine = cls.engine_class(params)
def test_set_alters_data(self):
template = self.engine.from_string(
"{% set test = User.objects.create_superuser("
"username='evil', email='a@b.com', password='xxx') %}"
"{{ test }}"
)
with self.assertRaises(jinja2.exceptions.SecurityError):
template.render(context={"User": User})
self.assertEqual(User.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/template_backends/test_utils.py | tests/template_backends/test_utils.py | from django.core.exceptions import ImproperlyConfigured
from django.template import engines
from django.test import SimpleTestCase, override_settings
class TemplateUtilsTests(SimpleTestCase):
@override_settings(TEMPLATES=[{"BACKEND": "raise.import.error"}])
def test_backend_import_error(self):
"""
Failing to import a backend keeps raising the original import error
(#24265).
"""
with self.assertRaisesMessage(ImportError, "No module named 'raise"):
engines.all()
with self.assertRaisesMessage(ImportError, "No module named 'raise"):
engines.all()
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
# Incorrect: APP_DIRS and loaders are mutually incompatible.
"APP_DIRS": True,
"OPTIONS": {"loaders": []},
}
]
)
def test_backend_improperly_configured(self):
"""
Failing to initialize a backend keeps raising the original exception
(#24265).
"""
msg = "app_dirs must not be set when loaders is defined."
with self.assertRaisesMessage(ImproperlyConfigured, msg):
engines.all()
with self.assertRaisesMessage(ImproperlyConfigured, msg):
engines.all()
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
},
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
},
]
)
def test_backend_names_must_be_unique(self):
msg = (
"Template engine aliases aren't unique, duplicates: django. Set "
"a unique NAME for each engine in settings.TEMPLATES."
)
with self.assertRaisesMessage(ImproperlyConfigured, msg):
engines.all()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/test_django.py | tests/template_backends/test_django.py | from pathlib import Path
from template_tests.test_response import test_processor_name
from django.template import Context, EngineHandler, RequestContext
from django.template.backends.django import DjangoTemplates
from django.template.library import InvalidTemplateLibrary
from django.test import RequestFactory, override_settings
from .test_dummy import TemplateStringsTests
class DjangoTemplatesTests(TemplateStringsTests):
engine_class = DjangoTemplates
backend_name = "django"
request_factory = RequestFactory()
def test_context_has_priority_over_template_context_processors(self):
# See ticket #23789.
engine = DjangoTemplates(
{
"DIRS": [],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {
"context_processors": [test_processor_name],
},
}
)
template = engine.from_string("{{ processors }}")
request = self.request_factory.get("/")
# Context processors run
content = template.render({}, request)
self.assertEqual(content, "yes")
# Context overrides context processors
content = template.render({"processors": "no"}, request)
self.assertEqual(content, "no")
def test_render_requires_dict(self):
"""django.Template.render() requires a dict."""
engine = DjangoTemplates(
{
"DIRS": [],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {},
}
)
template = engine.from_string("")
context = Context()
request_context = RequestContext(self.request_factory.get("/"), {})
msg = "context must be a dict rather than Context."
with self.assertRaisesMessage(TypeError, msg):
template.render(context)
msg = "context must be a dict rather than RequestContext."
with self.assertRaisesMessage(TypeError, msg):
template.render(request_context)
@override_settings(INSTALLED_APPS=["template_backends.apps.good"])
def test_templatetag_discovery(self):
engine = DjangoTemplates(
{
"DIRS": [],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {
"libraries": {
"alternate": (
"template_backends.apps.good.templatetags.good_tags"
),
"override": (
"template_backends.apps.good.templatetags.good_tags"
),
},
},
}
)
# libraries are discovered from installed applications
self.assertEqual(
engine.engine.libraries["good_tags"],
"template_backends.apps.good.templatetags.good_tags",
)
self.assertEqual(
engine.engine.libraries["subpackage.tags"],
"template_backends.apps.good.templatetags.subpackage.tags",
)
# libraries are discovered from django.templatetags
self.assertEqual(
engine.engine.libraries["static"],
"django.templatetags.static",
)
# libraries passed in OPTIONS are registered
self.assertEqual(
engine.engine.libraries["alternate"],
"template_backends.apps.good.templatetags.good_tags",
)
# libraries passed in OPTIONS take precedence over discovered ones
self.assertEqual(
engine.engine.libraries["override"],
"template_backends.apps.good.templatetags.good_tags",
)
@override_settings(INSTALLED_APPS=["template_backends.apps.importerror"])
def test_templatetag_discovery_import_error(self):
"""
Import errors in tag modules should be reraised with a helpful message.
"""
with self.assertRaisesMessage(
InvalidTemplateLibrary,
"ImportError raised when trying to load "
"'template_backends.apps.importerror.templatetags.broken_tags'",
) as cm:
DjangoTemplates(
{
"DIRS": [],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {},
}
)
self.assertIsInstance(cm.exception.__cause__, ImportError)
def test_builtins_discovery(self):
engine = DjangoTemplates(
{
"DIRS": [],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {
"builtins": ["template_backends.apps.good.templatetags.good_tags"],
},
}
)
self.assertEqual(
engine.engine.builtins,
[
"django.template.defaulttags",
"django.template.defaultfilters",
"django.template.loader_tags",
"template_backends.apps.good.templatetags.good_tags",
],
)
def test_autoescape_off(self):
templates = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"OPTIONS": {"autoescape": False},
}
]
engines = EngineHandler(templates=templates)
self.assertEqual(
engines["django"]
.from_string("Hello, {{ name }}")
.render({"name": "Bob & Jim"}),
"Hello, Bob & Jim",
)
def test_autoescape_default(self):
templates = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
}
]
engines = EngineHandler(templates=templates)
self.assertEqual(
engines["django"]
.from_string("Hello, {{ name }}")
.render({"name": "Bob & Jim"}),
"Hello, Bob & Jim",
)
def test_default_template_loaders(self):
"""The cached template loader is always enabled by default."""
for debug in (True, False):
with self.subTest(DEBUG=debug), self.settings(DEBUG=debug):
engine = DjangoTemplates(
{"DIRS": [], "APP_DIRS": True, "NAME": "django", "OPTIONS": {}}
)
self.assertEqual(
engine.engine.loaders,
[
(
"django.template.loaders.cached.Loader",
[
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
],
)
],
)
def test_dirs_pathlib(self):
engine = DjangoTemplates(
{
"DIRS": [Path(__file__).parent / "templates" / "template_backends"],
"APP_DIRS": False,
"NAME": "django",
"OPTIONS": {},
}
)
template = engine.get_template("hello.html")
self.assertEqual(template.render({"name": "Joe"}), "Hello Joe!\n")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/__init__.py | tests/template_backends/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/test_dummy.py | tests/template_backends/test_dummy.py | import re
from django.forms import CharField, Form, Media
from django.http import HttpRequest, HttpResponse
from django.middleware.csrf import (
CSRF_TOKEN_LENGTH,
CsrfViewMiddleware,
_unmask_cipher_token,
get_token,
)
from django.template import TemplateDoesNotExist, TemplateSyntaxError
from django.template.backends.dummy import TemplateStrings
from django.test import SimpleTestCase
class TemplateStringsTests(SimpleTestCase):
engine_class = TemplateStrings
backend_name = "dummy"
options = {}
@classmethod
def setUpClass(cls):
super().setUpClass()
params = {
"DIRS": [],
"APP_DIRS": True,
"NAME": cls.backend_name,
"OPTIONS": cls.options,
}
cls.engine = cls.engine_class(params)
def test_from_string(self):
template = self.engine.from_string("Hello!\n")
content = template.render()
self.assertEqual(content, "Hello!\n")
def test_get_template(self):
template = self.engine.get_template("template_backends/hello.html")
content = template.render({"name": "world"})
self.assertEqual(content, "Hello world!\n")
def test_get_template_nonexistent(self):
with self.assertRaises(TemplateDoesNotExist) as e:
self.engine.get_template("template_backends/nonexistent.html")
self.assertEqual(e.exception.backend, self.engine)
def test_get_template_syntax_error(self):
# There's no way to trigger a syntax error with the dummy backend.
# The test still lives here to factor it between other backends.
if self.backend_name == "dummy":
self.skipTest("test doesn't apply to dummy backend")
with self.assertRaises(TemplateSyntaxError):
self.engine.get_template("template_backends/syntax_error.html")
def test_html_escaping(self):
template = self.engine.get_template("template_backends/hello.html")
context = {"name": '<script>alert("XSS!");</script>'}
content = template.render(context)
self.assertIn("<script>", content)
self.assertNotIn("<script>", content)
def test_django_html_escaping(self):
if self.backend_name == "dummy":
self.skipTest("test doesn't apply to dummy backend")
class TestForm(Form):
test_field = CharField()
media = Media(js=["my-script.js"])
form = TestForm()
template = self.engine.get_template("template_backends/django_escaping.html")
content = template.render({"media": media, "test_form": form})
expected = "{}\n\n{}\n\n{}".format(media, form, form["test_field"])
self.assertHTMLEqual(content, expected)
def check_tokens_equivalent(self, token1, token2):
self.assertEqual(len(token1), CSRF_TOKEN_LENGTH)
self.assertEqual(len(token2), CSRF_TOKEN_LENGTH)
token1, token2 = map(_unmask_cipher_token, (token1, token2))
self.assertEqual(token1, token2)
def test_csrf_token(self):
request = HttpRequest()
CsrfViewMiddleware(lambda req: HttpResponse()).process_view(
request, lambda r: None, (), {}
)
template = self.engine.get_template("template_backends/csrf.html")
content = template.render(request=request)
expected = '<input type="hidden" name="csrfmiddlewaretoken" value="([^"]+)">'
match = re.match(expected, content) or re.match(
expected.replace('"', "'"), content
)
self.assertTrue(match, "hidden csrftoken field not found in output")
self.check_tokens_equivalent(match[1], get_token(request))
def test_no_directory_traversal(self):
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("../forbidden/template_backends/hello.html")
def test_non_ascii_characters(self):
template = self.engine.get_template("template_backends/hello.html")
content = template.render({"name": "Jérôme"})
self.assertEqual(content, "Hello Jérôme!\n")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/__init__.py | tests/template_backends/apps/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/__init__.py | tests/template_backends/apps/good/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/good_tags.py | tests/template_backends/apps/good/templatetags/good_tags.py | from django.template import Library
register = Library()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/__init__.py | tests/template_backends/apps/good/templatetags/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/empty.py | tests/template_backends/apps/good/templatetags/empty.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/override.py | tests/template_backends/apps/good/templatetags/override.py | from django.template import Library
register = Library()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/subpackage/tags.py | tests/template_backends/apps/good/templatetags/subpackage/tags.py | from django.template import Library
register = Library()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/good/templatetags/subpackage/__init__.py | tests/template_backends/apps/good/templatetags/subpackage/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/importerror/__init__.py | tests/template_backends/apps/importerror/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/importerror/templatetags/broken_tags.py | tests/template_backends/apps/importerror/templatetags/broken_tags.py | import DoesNotExist # noqa
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_backends/apps/importerror/templatetags/__init__.py | tests/template_backends/apps/importerror/templatetags/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/or_lookups/models.py | tests/or_lookups/models.py | """
OR lookups
To perform an OR lookup, or a lookup that combines ANDs and ORs, combine
``QuerySet`` objects using ``&`` and ``|`` operators.
Alternatively, use positional arguments, and pass one or more expressions of
clauses using the variable ``django.db.models.Q``.
"""
from django.db import models
class Article(models.Model):
headline = models.CharField(max_length=50)
pub_date = models.DateTimeField()
class Meta:
ordering = ("pub_date",)
def __str__(self):
return self.headline
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/or_lookups/__init__.py | tests/or_lookups/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/or_lookups/tests.py | tests/or_lookups/tests.py | from datetime import datetime
from operator import attrgetter
from django.db.models import Q
from django.test import TestCase
from .models import Article
class OrLookupsTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.a1 = Article.objects.create(
headline="Hello", pub_date=datetime(2005, 11, 27)
).pk
cls.a2 = Article.objects.create(
headline="Goodbye", pub_date=datetime(2005, 11, 28)
).pk
cls.a3 = Article.objects.create(
headline="Hello and goodbye", pub_date=datetime(2005, 11, 29)
).pk
def test_filter_or(self):
self.assertQuerySetEqual(
(
Article.objects.filter(headline__startswith="Hello")
| Article.objects.filter(headline__startswith="Goodbye")
),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(headline__contains="Hello")
| Article.objects.filter(headline__contains="bye"),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(headline__iexact="Hello")
| Article.objects.filter(headline__contains="ood"),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(
Q(headline__startswith="Hello") | Q(headline__startswith="Goodbye")
),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
def test_stages(self):
# You can shorten this syntax with code like the following, which is
# especially useful if building the query in stages:
articles = Article.objects.all()
self.assertQuerySetEqual(
articles.filter(headline__startswith="Hello")
& articles.filter(headline__startswith="Goodbye"),
[],
)
self.assertQuerySetEqual(
articles.filter(headline__startswith="Hello")
& articles.filter(headline__contains="bye"),
["Hello and goodbye"],
attrgetter("headline"),
)
def test_pk_q(self):
self.assertQuerySetEqual(
Article.objects.filter(Q(pk=self.a1) | Q(pk=self.a2)),
["Hello", "Goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(Q(pk=self.a1) | Q(pk=self.a2) | Q(pk=self.a3)),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
def test_pk_in(self):
self.assertQuerySetEqual(
Article.objects.filter(pk__in=[self.a1, self.a2, self.a3]),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(pk__in=(self.a1, self.a2, self.a3)),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(pk__in=[self.a1, self.a2, self.a3, 40000]),
["Hello", "Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
def test_q_repr(self):
or_expr = Q(baz=Article(headline="Foö"))
self.assertEqual(repr(or_expr), "<Q: (AND: ('baz', <Article: Foö>))>")
negated_or = ~Q(baz=Article(headline="Foö"))
self.assertEqual(repr(negated_or), "<Q: (NOT (AND: ('baz', <Article: Foö>)))>")
def test_q_negated(self):
# Q objects can be negated
self.assertQuerySetEqual(
Article.objects.filter(Q(pk=self.a1) | ~Q(pk=self.a2)),
["Hello", "Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(~Q(pk=self.a1) & ~Q(pk=self.a2)),
["Hello and goodbye"],
attrgetter("headline"),
)
# This allows for more complex queries than filter() and exclude()
# alone would allow
self.assertQuerySetEqual(
Article.objects.filter(Q(pk=self.a1) & (~Q(pk=self.a2) | Q(pk=self.a3))),
["Hello"],
attrgetter("headline"),
)
def test_complex_filter(self):
# The 'complex_filter' method supports framework features such as
# 'limit_choices_to' which normally take a single dictionary of lookup
# arguments but need to support arbitrary queries via Q objects too.
self.assertQuerySetEqual(
Article.objects.complex_filter({"pk": self.a1}),
["Hello"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.complex_filter(Q(pk=self.a1) | Q(pk=self.a2)),
["Hello", "Goodbye"],
attrgetter("headline"),
)
def test_empty_in(self):
# Passing "in" an empty list returns no results ...
self.assertQuerySetEqual(Article.objects.filter(pk__in=[]), [])
# ... but can return results if we OR it with another query.
self.assertQuerySetEqual(
Article.objects.filter(Q(pk__in=[]) | Q(headline__icontains="goodbye")),
["Goodbye", "Hello and goodbye"],
attrgetter("headline"),
)
def test_q_and(self):
# Q arg objects are ANDed
self.assertQuerySetEqual(
Article.objects.filter(
Q(headline__startswith="Hello"), Q(headline__contains="bye")
),
["Hello and goodbye"],
attrgetter("headline"),
)
# Q arg AND order is irrelevant
self.assertQuerySetEqual(
Article.objects.filter(
Q(headline__contains="bye"), headline__startswith="Hello"
),
["Hello and goodbye"],
attrgetter("headline"),
)
self.assertQuerySetEqual(
Article.objects.filter(
Q(headline__startswith="Hello") & Q(headline__startswith="Goodbye")
),
[],
)
def test_q_exclude(self):
self.assertQuerySetEqual(
Article.objects.exclude(Q(headline__startswith="Hello")),
["Goodbye"],
attrgetter("headline"),
)
def test_other_arg_queries(self):
# Try some arg queries with operations other than filter.
self.assertEqual(
Article.objects.get(
Q(headline__startswith="Hello"), Q(headline__contains="bye")
).headline,
"Hello and goodbye",
)
self.assertEqual(
Article.objects.filter(
Q(headline__startswith="Hello") | Q(headline__contains="bye")
).count(),
3,
)
self.assertSequenceEqual(
Article.objects.filter(
Q(headline__startswith="Hello"), Q(headline__contains="bye")
).values(),
[
{
"headline": "Hello and goodbye",
"id": self.a3,
"pub_date": datetime(2005, 11, 29),
},
],
)
self.assertEqual(
Article.objects.filter(Q(headline__startswith="Hello")).in_bulk(
[self.a1, self.a2]
),
{self.a1: Article.objects.get(pk=self.a1)},
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/expressions/models.py | tests/expressions/models.py | """
Tests for F() query expression syntax.
"""
import uuid
from django.db import models
class Manager(models.Model):
name = models.CharField(max_length=50)
secretary = models.ForeignKey(
"Employee", models.CASCADE, null=True, related_name="managers"
)
class Employee(models.Model):
firstname = models.CharField(max_length=50)
lastname = models.CharField(max_length=50)
salary = models.IntegerField(blank=True, null=True)
manager = models.ForeignKey(Manager, models.CASCADE, null=True)
based_in_eu = models.BooleanField(default=False)
def __str__(self):
return "%s %s" % (self.firstname, self.lastname)
class RemoteEmployee(Employee):
adjusted_salary = models.IntegerField()
class Company(models.Model):
name = models.CharField(max_length=100)
num_employees = models.PositiveIntegerField()
num_chairs = models.PositiveIntegerField()
ceo = models.ForeignKey(
Employee,
models.CASCADE,
related_name="company_ceo_set",
)
point_of_contact = models.ForeignKey(
Employee,
models.SET_NULL,
related_name="company_point_of_contact_set",
null=True,
)
based_in_eu = models.BooleanField(default=False)
def __str__(self):
return self.name
class Number(models.Model):
integer = models.BigIntegerField(db_column="the_integer")
float = models.FloatField(null=True, db_column="the_float")
decimal_value = models.DecimalField(max_digits=20, decimal_places=17, null=True)
def __str__(self):
return "%i, %s, %s" % (
self.integer,
"%.3f" % self.float if self.float is not None else None,
"%.17f" % self.decimal_value if self.decimal_value is not None else None,
)
class Experiment(models.Model):
name = models.CharField(max_length=24)
assigned = models.DateField()
completed = models.DateField()
estimated_time = models.DurationField()
start = models.DateTimeField()
end = models.DateTimeField()
scalar = models.IntegerField(null=True)
class Meta:
db_table = "expressions_ExPeRiMeNt"
ordering = ("name",)
def duration(self):
return self.end - self.start
class Result(models.Model):
experiment = models.ForeignKey(Experiment, models.CASCADE)
result_time = models.DateTimeField()
def __str__(self):
return "Result at %s" % self.result_time
class Time(models.Model):
time = models.TimeField(null=True)
def __str__(self):
return str(self.time)
class SimulationRun(models.Model):
start = models.ForeignKey(Time, models.CASCADE, null=True, related_name="+")
end = models.ForeignKey(Time, models.CASCADE, null=True, related_name="+")
midpoint = models.TimeField()
def __str__(self):
return "%s (%s to %s)" % (self.midpoint, self.start, self.end)
class UUIDPK(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4)
class UUID(models.Model):
uuid = models.UUIDField(null=True)
uuid_fk = models.ForeignKey(UUIDPK, models.CASCADE, null=True)
class Text(models.Model):
name = models.TextField()
class JSONFieldModel(models.Model):
data = models.JSONField(null=True)
class Meta:
required_db_features = {"supports_json_field"}
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/expressions/__init__.py | tests/expressions/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/expressions/tests.py | tests/expressions/tests.py | import datetime
import pickle
import unittest
import uuid
from collections import namedtuple
from copy import deepcopy
from decimal import Decimal
from unittest import mock
from django.core.exceptions import FieldError
from django.db import DatabaseError, NotSupportedError, connection
from django.db.models import (
AutoField,
Avg,
BinaryField,
BooleanField,
Case,
CharField,
Count,
DateField,
DateTimeField,
DecimalField,
DurationField,
Exists,
Expression,
ExpressionList,
ExpressionWrapper,
F,
FloatField,
Func,
IntegerField,
JSONField,
Max,
Min,
Model,
OrderBy,
OuterRef,
PositiveIntegerField,
Q,
StdDev,
Subquery,
Sum,
TimeField,
UUIDField,
Value,
Variance,
When,
)
from django.db.models.expressions import (
Col,
ColPairs,
Combinable,
CombinedExpression,
NegatedExpression,
OutputFieldIsNoneError,
RawSQL,
Ref,
)
from django.db.models.functions import (
Coalesce,
Concat,
ExtractDay,
Left,
Length,
Lower,
Substr,
TruncDate,
Upper,
)
from django.db.models.sql import constants
from django.db.models.sql.datastructures import Join
from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
from django.test.utils import (
Approximate,
CaptureQueriesContext,
isolate_apps,
register_lookup,
)
from django.utils.functional import SimpleLazyObject
from .models import (
UUID,
UUIDPK,
Company,
Employee,
Experiment,
JSONFieldModel,
Manager,
Number,
RemoteEmployee,
Result,
SimulationRun,
Text,
Time,
)
class BasicExpressionsTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.example_inc = Company.objects.create(
name="Example Inc.",
num_employees=2300,
num_chairs=5,
ceo=Employee.objects.create(firstname="Joe", lastname="Smith", salary=10),
)
cls.foobar_ltd = Company.objects.create(
name="Foobar Ltd.",
num_employees=3,
num_chairs=4,
based_in_eu=True,
ceo=Employee.objects.create(firstname="Frank", lastname="Meyer", salary=20),
)
cls.max = Employee.objects.create(
firstname="Max", lastname="Mustermann", salary=30
)
cls.gmbh = Company.objects.create(
name="Test GmbH", num_employees=32, num_chairs=1, ceo=cls.max
)
def setUp(self):
self.company_query = Company.objects.values(
"name", "num_employees", "num_chairs"
).order_by("name", "num_employees", "num_chairs")
def test_annotate_values_aggregate(self):
companies = (
Company.objects.annotate(
salaries=F("ceo__salary"),
)
.values("num_employees", "salaries")
.aggregate(
result=Sum(
F("salaries") + F("num_employees"), output_field=IntegerField()
),
)
)
self.assertEqual(companies["result"], 2395)
def test_annotate_values_filter(self):
companies = (
Company.objects.annotate(
foo=RawSQL("%s", ["value"]),
)
.filter(foo="value")
.order_by("name")
)
self.assertSequenceEqual(
companies,
[self.example_inc, self.foobar_ltd, self.gmbh],
)
def test_annotate_values_count(self):
companies = Company.objects.annotate(foo=RawSQL("%s", ["value"]))
self.assertEqual(companies.count(), 3)
@skipUnlessDBFeature("supports_boolean_expr_in_select_clause")
def test_filtering_on_annotate_that_uses_q(self):
self.assertEqual(
Company.objects.annotate(
num_employees_check=ExpressionWrapper(
Q(num_employees__gt=3), output_field=BooleanField()
)
)
.filter(num_employees_check=True)
.count(),
2,
)
def test_filtering_on_q_that_is_boolean(self):
self.assertEqual(
Company.objects.filter(
ExpressionWrapper(Q(num_employees__gt=3), output_field=BooleanField())
).count(),
2,
)
def test_filtering_on_rawsql_that_is_boolean(self):
self.assertEqual(
Company.objects.filter(
RawSQL("num_employees > %s", (3,), output_field=BooleanField()),
).count(),
2,
)
def test_filter_inter_attribute(self):
# We can filter on attribute relationships on same model obj, e.g.
# find companies where the number of employees is greater
# than the number of chairs.
self.assertSequenceEqual(
self.company_query.filter(num_employees__gt=F("num_chairs")),
[
{
"num_chairs": 5,
"name": "Example Inc.",
"num_employees": 2300,
},
{"num_chairs": 1, "name": "Test GmbH", "num_employees": 32},
],
)
def test_update(self):
# We can set one field to have the value of another field
# Make sure we have enough chairs
self.company_query.update(num_chairs=F("num_employees"))
self.assertSequenceEqual(
self.company_query,
[
{"num_chairs": 2300, "name": "Example Inc.", "num_employees": 2300},
{"num_chairs": 3, "name": "Foobar Ltd.", "num_employees": 3},
{"num_chairs": 32, "name": "Test GmbH", "num_employees": 32},
],
)
def _test_slicing_of_f_expressions(self, model):
tests = [
(F("name")[:], "Example Inc."),
(F("name")[:7], "Example"),
(F("name")[:6][:5], "Examp"), # Nested slicing.
(F("name")[0], "E"),
(F("name")[13], ""),
(F("name")[8:], "Inc."),
(F("name")[0:15], "Example Inc."),
(F("name")[2:7], "ample"),
(F("name")[1:][:3], "xam"),
(F("name")[2:2], ""),
]
for expression, expected in tests:
with self.subTest(expression=expression, expected=expected):
obj = model.objects.get(name="Example Inc.")
try:
obj.name = expression
obj.save(update_fields=["name"])
obj.refresh_from_db()
self.assertEqual(obj.name, expected)
finally:
obj.name = "Example Inc."
obj.save(update_fields=["name"])
def test_slicing_of_f_expressions_charfield(self):
self._test_slicing_of_f_expressions(Company)
def test_slicing_of_f_expressions_textfield(self):
Text.objects.bulk_create(
[Text(name=company.name) for company in Company.objects.all()]
)
self._test_slicing_of_f_expressions(Text)
def test_slicing_of_f_expressions_with_annotate(self):
qs = Company.objects.annotate(
first_three=F("name")[:3],
after_three=F("name")[3:],
random_four=F("name")[2:5],
first_letter_slice=F("name")[:1],
first_letter_index=F("name")[0],
)
tests = [
("first_three", ["Exa", "Foo", "Tes"]),
("after_three", ["mple Inc.", "bar Ltd.", "t GmbH"]),
("random_four", ["amp", "oba", "st "]),
("first_letter_slice", ["E", "F", "T"]),
("first_letter_index", ["E", "F", "T"]),
]
for annotation, expected in tests:
with self.subTest(annotation):
self.assertCountEqual(qs.values_list(annotation, flat=True), expected)
def test_slicing_of_f_expression_with_annotated_expression(self):
qs = Company.objects.annotate(
new_name=Case(
When(based_in_eu=True, then=Concat(Value("EU:"), F("name"))),
default=F("name"),
),
first_two=F("new_name")[:3],
)
self.assertCountEqual(
qs.values_list("first_two", flat=True),
["Exa", "EU:", "Tes"],
)
def test_slicing_of_f_expressions_with_negative_index(self):
msg = "Negative indexing is not supported."
indexes = [slice(0, -4), slice(-4, 0), slice(-4), -5]
for i in indexes:
with self.subTest(i=i), self.assertRaisesMessage(ValueError, msg):
F("name")[i]
def test_slicing_of_f_expressions_with_slice_stop_less_than_slice_start(self):
msg = "Slice stop must be greater than slice start."
with self.assertRaisesMessage(ValueError, msg):
F("name")[4:2]
def test_slicing_of_f_expressions_with_invalid_type(self):
msg = "Argument to slice must be either int or slice instance."
with self.assertRaisesMessage(TypeError, msg):
F("name")["error"]
def test_slicing_of_f_expressions_with_step(self):
msg = "Step argument is not supported."
with self.assertRaisesMessage(ValueError, msg):
F("name")[::4]
def test_slicing_of_f_unsupported_field(self):
msg = "This field does not support slicing."
with self.assertRaisesMessage(NotSupportedError, msg):
Company.objects.update(num_chairs=F("num_chairs")[:4])
def test_slicing_of_outerref(self):
inner = Company.objects.filter(name__startswith=OuterRef("ceo__firstname")[0])
outer = Company.objects.filter(Exists(inner)).values_list("name", flat=True)
self.assertSequenceEqual(outer, ["Foobar Ltd."])
def test_arithmetic(self):
# We can perform arithmetic operations in expressions
# Make sure we have 2 spare chairs
self.company_query.update(num_chairs=F("num_employees") + 2)
self.assertSequenceEqual(
self.company_query,
[
{"num_chairs": 2302, "name": "Example Inc.", "num_employees": 2300},
{"num_chairs": 5, "name": "Foobar Ltd.", "num_employees": 3},
{"num_chairs": 34, "name": "Test GmbH", "num_employees": 32},
],
)
def test_order_of_operations(self):
# Law of order of operations is followed
self.company_query.update(
num_chairs=F("num_employees") + 2 * F("num_employees")
)
self.assertSequenceEqual(
self.company_query,
[
{"num_chairs": 6900, "name": "Example Inc.", "num_employees": 2300},
{"num_chairs": 9, "name": "Foobar Ltd.", "num_employees": 3},
{"num_chairs": 96, "name": "Test GmbH", "num_employees": 32},
],
)
def test_parenthesis_priority(self):
# Law of order of operations can be overridden by parentheses
self.company_query.update(
num_chairs=(F("num_employees") + 2) * F("num_employees")
)
self.assertSequenceEqual(
self.company_query,
[
{"num_chairs": 5294600, "name": "Example Inc.", "num_employees": 2300},
{"num_chairs": 15, "name": "Foobar Ltd.", "num_employees": 3},
{"num_chairs": 1088, "name": "Test GmbH", "num_employees": 32},
],
)
def test_update_with_fk(self):
# ForeignKey can become updated with the value of another ForeignKey.
self.assertEqual(Company.objects.update(point_of_contact=F("ceo")), 3)
self.assertQuerySetEqual(
Company.objects.all(),
["Joe Smith", "Frank Meyer", "Max Mustermann"],
lambda c: str(c.point_of_contact),
ordered=False,
)
def test_update_with_none(self):
Number.objects.create(integer=1, float=1.0)
Number.objects.create(integer=2)
Number.objects.filter(float__isnull=False).update(float=Value(None))
self.assertQuerySetEqual(
Number.objects.all(), [None, None], lambda n: n.float, ordered=False
)
@skipUnlessDBFeature("supports_json_field")
def test_update_jsonfield_case_when_key_is_null(self):
obj = JSONFieldModel.objects.create(data={"key": None})
updated = JSONFieldModel.objects.update(
data=Case(
When(
data__key=Value(None, JSONField()),
then=Value({"key": "something"}, JSONField()),
),
)
)
self.assertEqual(updated, 1)
obj.refresh_from_db()
self.assertEqual(obj.data, {"key": "something"})
def test_filter_with_join(self):
# F Expressions can also span joins
Company.objects.update(point_of_contact=F("ceo"))
c = Company.objects.first()
c.point_of_contact = Employee.objects.create(
firstname="Guido", lastname="van Rossum"
)
c.save()
self.assertQuerySetEqual(
Company.objects.filter(ceo__firstname=F("point_of_contact__firstname")),
["Foobar Ltd.", "Test GmbH"],
lambda c: c.name,
ordered=False,
)
Company.objects.exclude(ceo__firstname=F("point_of_contact__firstname")).update(
name="foo"
)
self.assertEqual(
Company.objects.exclude(ceo__firstname=F("point_of_contact__firstname"))
.get()
.name,
"foo",
)
msg = "Joined field references are not permitted in this query"
with self.assertRaisesMessage(FieldError, msg):
Company.objects.exclude(
ceo__firstname=F("point_of_contact__firstname")
).update(name=F("point_of_contact__lastname"))
def test_object_update(self):
# F expressions can be used to update attributes on single objects
self.gmbh.num_employees = F("num_employees") + 4
self.gmbh.save()
expected_num_queries = (
0 if connection.features.can_return_rows_from_update else 1
)
with self.assertNumQueries(expected_num_queries):
self.assertEqual(self.gmbh.num_employees, 36)
def test_new_object_save(self):
# We should be able to use Funcs when inserting new data
test_co = Company(
name=Lower(Value("UPPER")), num_employees=32, num_chairs=1, ceo=self.max
)
test_co.save()
test_co.refresh_from_db()
self.assertEqual(test_co.name, "upper")
def test_new_object_create(self):
test_co = Company.objects.create(
name=Lower(Value("UPPER")), num_employees=32, num_chairs=1, ceo=self.max
)
test_co.refresh_from_db()
self.assertEqual(test_co.name, "upper")
def test_object_create_with_aggregate(self):
# Aggregates are not allowed when inserting new data
msg = (
"Aggregate functions are not allowed in this query "
"(num_employees=Max(Value(1)))."
)
with self.assertRaisesMessage(FieldError, msg):
Company.objects.create(
name="Company",
num_employees=Max(Value(1)),
num_chairs=1,
ceo=Employee.objects.create(
firstname="Just", lastname="Doit", salary=30
),
)
def test_object_update_fk(self):
# F expressions cannot be used to update attributes which are foreign
# keys, or attributes which involve joins.
test_gmbh = Company.objects.get(pk=self.gmbh.pk)
msg = 'F(ceo)": "Company.point_of_contact" must be a "Employee" instance.'
with self.assertRaisesMessage(ValueError, msg):
test_gmbh.point_of_contact = F("ceo")
test_gmbh.point_of_contact = self.gmbh.ceo
test_gmbh.save()
test_gmbh.name = F("ceo__lastname")
msg = "Joined field references are not permitted in this query"
with self.assertRaisesMessage(FieldError, msg):
test_gmbh.save()
def test_update_inherited_field_value(self):
msg = "Joined field references are not permitted in this query"
with self.assertRaisesMessage(FieldError, msg):
RemoteEmployee.objects.update(adjusted_salary=F("salary") * 5)
def test_object_update_unsaved_objects(self):
# F expressions cannot be used to update attributes on objects which do
# not yet exist in the database
acme = Company(
name="The Acme Widget Co.", num_employees=12, num_chairs=5, ceo=self.max
)
acme.num_employees = F("num_employees") + 16
msg = (
'Failed to insert expression "Col(expressions_company, '
'expressions.Company.num_employees) + Value(16)" on '
"expressions.Company.num_employees. F() expressions can only be "
"used to update, not to insert."
)
with self.assertRaisesMessage(ValueError, msg):
acme.save()
acme.num_employees = 12
acme.name = Lower(F("name"))
msg = (
'Failed to insert expression "Lower(Col(expressions_company, '
'expressions.Company.name))" on expressions.Company.name. F() '
"expressions can only be used to update, not to insert."
)
with self.assertRaisesMessage(ValueError, msg):
acme.save()
def test_ticket_11722_iexact_lookup(self):
Employee.objects.create(firstname="John", lastname="Doe")
test = Employee.objects.create(firstname="Test", lastname="test")
queryset = Employee.objects.filter(firstname__iexact=F("lastname"))
self.assertSequenceEqual(queryset, [test])
def test_ticket_16731_startswith_lookup(self):
Employee.objects.create(firstname="John", lastname="Doe")
e2 = Employee.objects.create(firstname="Jack", lastname="Jackson")
e3 = Employee.objects.create(firstname="Jack", lastname="jackson")
self.assertSequenceEqual(
Employee.objects.filter(lastname__startswith=F("firstname")),
[e2, e3] if connection.features.has_case_insensitive_like else [e2],
)
qs = Employee.objects.filter(lastname__istartswith=F("firstname")).order_by(
"pk"
)
self.assertSequenceEqual(qs, [e2, e3])
def test_ticket_18375_join_reuse(self):
# Reverse multijoin F() references and the lookup target the same join.
# Pre #18375 the F() join was generated first and the lookup couldn't
# reuse that join.
qs = Employee.objects.filter(
company_ceo_set__num_chairs=F("company_ceo_set__num_employees")
)
self.assertEqual(str(qs.query).count("JOIN"), 1)
def test_ticket_18375_kwarg_ordering(self):
# The next query was dict-randomization dependent - if the "gte=1"
# was seen first, then the F() will reuse the join generated by the
# gte lookup, if F() was seen first, then it generated a join the
# other lookups could not reuse.
qs = Employee.objects.filter(
company_ceo_set__num_chairs=F("company_ceo_set__num_employees"),
company_ceo_set__num_chairs__gte=1,
)
self.assertEqual(str(qs.query).count("JOIN"), 1)
def test_ticket_18375_kwarg_ordering_2(self):
# Another similar case for F() than above. Now we have the same join
# in two filter kwargs, one in the lhs lookup, one in F. Here pre
# #18375 the amount of joins generated was random if dict
# randomization was enabled, that is the generated query dependent
# on which clause was seen first.
qs = Employee.objects.filter(
company_ceo_set__num_employees=F("pk"),
pk=F("company_ceo_set__num_employees"),
)
self.assertEqual(str(qs.query).count("JOIN"), 1)
def test_ticket_18375_chained_filters(self):
# F() expressions do not reuse joins from previous filter.
qs = Employee.objects.filter(company_ceo_set__num_employees=F("pk")).filter(
company_ceo_set__num_employees=F("company_ceo_set__num_employees")
)
self.assertEqual(str(qs.query).count("JOIN"), 2)
def test_order_by_exists(self):
mary = Employee.objects.create(
firstname="Mary", lastname="Mustermann", salary=20
)
mustermanns_by_seniority = Employee.objects.filter(
lastname="Mustermann"
).order_by(
# Order by whether the employee is the CEO of a company
Exists(Company.objects.filter(ceo=OuterRef("pk"))).desc()
)
self.assertSequenceEqual(mustermanns_by_seniority, [self.max, mary])
def test_order_by_multiline_sql(self):
raw_order_by = (
RawSQL(
"""
CASE WHEN num_employees > 1000
THEN num_chairs
ELSE 0 END
""",
[],
).desc(),
RawSQL(
"""
CASE WHEN num_chairs > 1
THEN 1
ELSE 0 END
""",
[],
).asc(),
)
for qs in (
Company.objects.all(),
Company.objects.distinct(),
):
with self.subTest(qs=qs):
self.assertSequenceEqual(
qs.order_by(*raw_order_by),
[self.example_inc, self.gmbh, self.foobar_ltd],
)
def test_outerref(self):
inner = Company.objects.filter(point_of_contact=OuterRef("pk"))
msg = (
"This queryset contains a reference to an outer query and may only "
"be used in a subquery."
)
with self.assertRaisesMessage(ValueError, msg):
inner.exists()
outer = Employee.objects.annotate(is_point_of_contact=Exists(inner))
self.assertIs(outer.exists(), True)
def test_exist_single_field_output_field(self):
queryset = Company.objects.values("pk")
self.assertIsInstance(Exists(queryset).output_field, BooleanField)
def test_subquery(self):
Company.objects.filter(name="Example Inc.").update(
point_of_contact=Employee.objects.get(firstname="Joe", lastname="Smith"),
ceo=self.max,
)
Employee.objects.create(firstname="Bob", lastname="Brown", salary=40)
qs = (
Employee.objects.annotate(
is_point_of_contact=Exists(
Company.objects.filter(point_of_contact=OuterRef("pk"))
),
is_not_point_of_contact=~Exists(
Company.objects.filter(point_of_contact=OuterRef("pk"))
),
is_ceo_of_small_company=Exists(
Company.objects.filter(num_employees__lt=200, ceo=OuterRef("pk"))
),
is_ceo_small_2=~~Exists(
Company.objects.filter(num_employees__lt=200, ceo=OuterRef("pk"))
),
largest_company=Subquery(
Company.objects.order_by("-num_employees")
.filter(Q(ceo=OuterRef("pk")) | Q(point_of_contact=OuterRef("pk")))
.values("name")[:1],
output_field=CharField(),
),
)
.values(
"firstname",
"is_point_of_contact",
"is_not_point_of_contact",
"is_ceo_of_small_company",
"is_ceo_small_2",
"largest_company",
)
.order_by("firstname")
)
results = list(qs)
# Could use Coalesce(subq, Value('')) instead except for the bug in
# oracledb mentioned in #23843.
bob = results[0]
if (
bob["largest_company"] == ""
and connection.features.interprets_empty_strings_as_nulls
):
bob["largest_company"] = None
self.assertEqual(
results,
[
{
"firstname": "Bob",
"is_point_of_contact": False,
"is_not_point_of_contact": True,
"is_ceo_of_small_company": False,
"is_ceo_small_2": False,
"largest_company": None,
},
{
"firstname": "Frank",
"is_point_of_contact": False,
"is_not_point_of_contact": True,
"is_ceo_of_small_company": True,
"is_ceo_small_2": True,
"largest_company": "Foobar Ltd.",
},
{
"firstname": "Joe",
"is_point_of_contact": True,
"is_not_point_of_contact": False,
"is_ceo_of_small_company": False,
"is_ceo_small_2": False,
"largest_company": "Example Inc.",
},
{
"firstname": "Max",
"is_point_of_contact": False,
"is_not_point_of_contact": True,
"is_ceo_of_small_company": True,
"is_ceo_small_2": True,
"largest_company": "Example Inc.",
},
],
)
# A less elegant way to write the same query: this uses a LEFT OUTER
# JOIN and an IS NULL, inside a WHERE NOT IN which is probably less
# efficient than EXISTS.
self.assertCountEqual(
qs.filter(is_point_of_contact=True).values("pk"),
Employee.objects.exclude(company_point_of_contact_set=None).values("pk"),
)
def test_subquery_eq(self):
qs = Employee.objects.annotate(
is_ceo=Exists(Company.objects.filter(ceo=OuterRef("pk"))),
is_point_of_contact=Exists(
Company.objects.filter(point_of_contact=OuterRef("pk")),
),
small_company=Exists(
queryset=Company.objects.filter(num_employees__lt=200),
),
).filter(is_ceo=True, is_point_of_contact=False, small_company=True)
self.assertNotEqual(
qs.query.annotations["is_ceo"],
qs.query.annotations["is_point_of_contact"],
)
self.assertNotEqual(
qs.query.annotations["is_ceo"],
qs.query.annotations["small_company"],
)
def test_subquery_sql(self):
employees = Employee.objects.all()
employees_subquery = Subquery(employees)
self.assertIs(employees_subquery.query.subquery, True)
self.assertIs(employees.query.subquery, False)
compiler = employees_subquery.query.get_compiler(connection=connection)
sql, _ = employees_subquery.as_sql(compiler, connection)
self.assertIn("(SELECT ", sql)
def test_in_subquery(self):
# This is a contrived test (and you really wouldn't write this query),
# but it is a succinct way to test the __in=Subquery() construct.
small_companies = Company.objects.filter(num_employees__lt=200).values("pk")
subquery_test = Company.objects.filter(pk__in=Subquery(small_companies))
self.assertCountEqual(subquery_test, [self.foobar_ltd, self.gmbh])
subquery_test2 = Company.objects.filter(
pk=Subquery(small_companies.filter(num_employees=3)[:1])
)
self.assertCountEqual(subquery_test2, [self.foobar_ltd])
def test_lookups_subquery(self):
smallest_company = Company.objects.order_by("num_employees").values("name")[:1]
for lookup in CharField.get_lookups():
if lookup == "isnull":
continue # not allowed, rhs must be a literal boolean.
if (
lookup == "in"
and not connection.features.allow_sliced_subqueries_with_in
):
continue
if lookup == "range":
rhs = (Subquery(smallest_company), Subquery(smallest_company))
else:
rhs = Subquery(smallest_company)
with self.subTest(lookup=lookup):
qs = Company.objects.filter(**{f"name__{lookup}": rhs})
self.assertGreater(len(qs), 0)
def test_uuid_pk_subquery(self):
u = UUIDPK.objects.create()
UUID.objects.create(uuid_fk=u)
qs = UUIDPK.objects.filter(id__in=Subquery(UUID.objects.values("uuid_fk__id")))
self.assertCountEqual(qs, [u])
def test_nested_subquery(self):
inner = Company.objects.filter(point_of_contact=OuterRef("pk"))
outer = Employee.objects.annotate(is_point_of_contact=Exists(inner))
contrived = Employee.objects.annotate(
is_point_of_contact=Subquery(
outer.filter(pk=OuterRef("pk")).values("is_point_of_contact"),
output_field=BooleanField(),
),
)
self.assertCountEqual(contrived.values_list(), outer.values_list())
def test_nested_subquery_join_outer_ref(self):
inner = Employee.objects.filter(pk=OuterRef("ceo__pk")).values("pk")
qs = Employee.objects.annotate(
ceo_company=Subquery(
Company.objects.filter(
ceo__in=inner,
ceo__pk=OuterRef("pk"),
).values("pk"),
),
)
self.assertSequenceEqual(
qs.values_list("ceo_company", flat=True),
[self.example_inc.pk, self.foobar_ltd.pk, self.gmbh.pk],
)
def test_nested_subquery_outer_ref_2(self):
first = Time.objects.create(time="09:00")
second = Time.objects.create(time="17:00")
third = Time.objects.create(time="21:00")
SimulationRun.objects.bulk_create(
[
SimulationRun(start=first, end=second, midpoint="12:00"),
SimulationRun(start=first, end=third, midpoint="15:00"),
SimulationRun(start=second, end=first, midpoint="00:00"),
]
)
inner = Time.objects.filter(
time=OuterRef(OuterRef("time")), pk=OuterRef("start")
).values("time")
middle = SimulationRun.objects.annotate(other=Subquery(inner)).values("other")[
:1
]
outer = Time.objects.annotate(other=Subquery(middle, output_field=TimeField()))
# This is a contrived example. It exercises the double OuterRef form.
self.assertCountEqual(outer, [first, second, third])
def test_nested_subquery_outer_ref_with_autofield(self):
first = Time.objects.create(time="09:00")
second = Time.objects.create(time="17:00")
SimulationRun.objects.create(start=first, end=second, midpoint="12:00")
inner = SimulationRun.objects.filter(start=OuterRef(OuterRef("pk"))).values(
"start"
)
middle = Time.objects.annotate(other=Subquery(inner)).values("other")[:1]
outer = Time.objects.annotate(
other=Subquery(middle, output_field=IntegerField())
)
# This exercises the double OuterRef form with AutoField as pk.
self.assertCountEqual(outer, [first, second])
def test_annotations_within_subquery(self):
Company.objects.filter(num_employees__lt=50).update(
ceo=Employee.objects.get(firstname="Frank")
)
inner = (
Company.objects.filter(ceo=OuterRef("pk"))
.values("ceo")
.annotate(total_employees=Sum("num_employees"))
.values("total_employees")
)
outer = Employee.objects.annotate(total_employees=Subquery(inner)).filter(
salary__lte=Subquery(inner)
)
self.assertSequenceEqual(
outer.order_by("-total_employees").values("salary", "total_employees"),
[
{"salary": 10, "total_employees": 2300},
{"salary": 20, "total_employees": 35},
],
)
def test_subquery_references_joined_table_twice(self):
inner = Company.objects.filter(
num_chairs__gte=OuterRef("ceo__salary"),
num_employees__gte=OuterRef("point_of_contact__salary"),
)
# Another contrived example (there is no need to have a subquery here)
outer = Company.objects.filter(pk__in=Subquery(inner.values("pk")))
self.assertFalse(outer.exists())
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/expressions/test_queryset_values.py | tests/expressions/test_queryset_values.py | from django.db.models import F, Sum
from django.test import TestCase, skipUnlessDBFeature
from django.utils.deprecation import RemovedInDjango70Warning
from .models import Company, Employee, JSONFieldModel
class ValuesExpressionsTests(TestCase):
@classmethod
def setUpTestData(cls):
Company.objects.create(
name="Example Inc.",
num_employees=2300,
num_chairs=5,
ceo=Employee.objects.create(firstname="Joe", lastname="Smith", salary=10),
)
Company.objects.create(
name="Foobar Ltd.",
num_employees=3,
num_chairs=4,
ceo=Employee.objects.create(firstname="Frank", lastname="Meyer", salary=20),
)
Company.objects.create(
name="Test GmbH",
num_employees=32,
num_chairs=1,
ceo=Employee.objects.create(
firstname="Max", lastname="Mustermann", salary=30
),
)
def test_values_expression(self):
self.assertSequenceEqual(
Company.objects.values(salary=F("ceo__salary")),
[{"salary": 10}, {"salary": 20}, {"salary": 30}],
)
def test_values_expression_containing_percent_sign_deprecation_warns_once(self):
msg = "Using percent signs in a column alias is deprecated."
with self.assertWarnsMessage(RemovedInDjango70Warning, msg) as cm:
Company.objects.values(**{"alias%": F("id")})
self.assertEqual(len(cm.warnings), 1)
def test_values_expression_alias_sql_injection(self):
crafted_alias = """injected_name" from "expressions_company"; --"""
msg = (
"Column aliases cannot contain whitespace characters, hashes, quotation "
"marks, semicolons, or SQL comments."
)
with self.assertRaisesMessage(ValueError, msg):
Company.objects.values(**{crafted_alias: F("ceo__salary")})
@skipUnlessDBFeature("supports_json_field")
def test_values_expression_alias_sql_injection_json_field(self):
crafted_alias = """injected_name" from "expressions_company"; --"""
msg = (
"Column aliases cannot contain whitespace characters, hashes, quotation "
"marks, semicolons, or SQL comments."
)
with self.assertRaisesMessage(ValueError, msg):
JSONFieldModel.objects.values(f"data__{crafted_alias}")
with self.assertRaisesMessage(ValueError, msg):
JSONFieldModel.objects.values_list(f"data__{crafted_alias}")
def test_values_expression_group_by(self):
# values() applies annotate() first, so values selected are grouped by
# id, not firstname.
Employee.objects.create(firstname="Joe", lastname="Jones", salary=2)
joes = Employee.objects.filter(firstname="Joe")
self.assertSequenceEqual(
joes.values("firstname", sum_salary=Sum("salary")).order_by("sum_salary"),
[
{"firstname": "Joe", "sum_salary": 2},
{"firstname": "Joe", "sum_salary": 10},
],
)
self.assertSequenceEqual(
joes.values("firstname").annotate(sum_salary=Sum("salary")),
[{"firstname": "Joe", "sum_salary": 12}],
)
def test_chained_values_with_expression(self):
Employee.objects.create(firstname="Joe", lastname="Jones", salary=2)
joes = Employee.objects.filter(firstname="Joe").values("firstname")
self.assertSequenceEqual(
joes.values("firstname", sum_salary=Sum("salary")),
[{"firstname": "Joe", "sum_salary": 12}],
)
self.assertSequenceEqual(
joes.values(sum_salary=Sum("salary")), [{"sum_salary": 12}]
)
def test_values_list_expression(self):
companies = Company.objects.values_list("name", F("ceo__salary"))
self.assertCountEqual(
companies, [("Example Inc.", 10), ("Foobar Ltd.", 20), ("Test GmbH", 30)]
)
def test_values_list_expression_flat(self):
companies = Company.objects.values_list(F("ceo__salary"), flat=True)
self.assertCountEqual(companies, (10, 20, 30))
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_default_site/sites.py | tests/admin_default_site/sites.py | from django.contrib import admin
class CustomAdminSite(admin.AdminSite):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_default_site/__init__.py | tests/admin_default_site/__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_default_site/tests.py | tests/admin_default_site/tests.py | from django.contrib import admin
from django.contrib.admin import sites
from django.test import SimpleTestCase, override_settings
from .sites import CustomAdminSite
@override_settings(
INSTALLED_APPS=[
"admin_default_site.apps.MyCustomAdminConfig",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
]
)
class CustomAdminSiteTests(SimpleTestCase):
def setUp(self):
# Reset admin.site since it may have already been instantiated by
# another test app.
self._old_site = admin.site
admin.site = sites.site = sites.DefaultAdminSite()
def tearDown(self):
admin.site = sites.site = self._old_site
def test_use_custom_admin_site(self):
self.assertEqual(admin.site.__class__.__name__, "CustomAdminSite")
class DefaultAdminSiteTests(SimpleTestCase):
def test_use_default_admin_site(self):
self.assertEqual(admin.site.__class__.__name__, "AdminSite")
def test_repr(self):
self.assertEqual(str(admin.site), "AdminSite(name='admin')")
self.assertEqual(repr(admin.site), "AdminSite(name='admin')")
class AdminSiteTests(SimpleTestCase):
def test_repr(self):
admin_site = CustomAdminSite(name="other")
self.assertEqual(repr(admin_site), "CustomAdminSite(name='other')")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_default_site/apps.py | tests/admin_default_site/apps.py | from django.contrib.admin.apps import SimpleAdminConfig
class MyCustomAdminConfig(SimpleAdminConfig):
verbose_name = "My custom default admin site."
default_site = "admin_default_site.sites.CustomAdminSite"
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/views.py | tests/test_client_regress/views.py | from urllib.parse import urlencode
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
from django.shortcuts import render
from django.template.loader import render_to_string
from django.test import Client
from django.test.client import CONTENT_TYPE_RE
class CustomTestException(Exception):
pass
def no_template_view(request):
"A simple view that expects a GET request, and returns a rendered template"
return HttpResponse(
"No template used. Sample content: twice once twice. Content ends."
)
def staff_only_view(request):
"""
A view that can only be visited by staff. Non staff members get an
exception
"""
if request.user.is_staff:
return HttpResponse()
else:
raise CustomTestException()
@login_required
def get_view(request):
"A simple login protected view"
return HttpResponse("Hello world")
def request_data(request, template="base.html", data="sausage"):
"A simple view that returns the request data in the context"
return render(
request,
template,
{
"get-foo": request.GET.get("foo"),
"get-bar": request.GET.get("bar"),
"post-foo": request.POST.get("foo"),
"post-bar": request.POST.get("bar"),
"data": data,
},
)
def view_with_argument(request, name):
"""A view that takes a string argument
The purpose of this view is to check that if a space is provided in
the argument, the test framework unescapes the %20 before passing
the value to the view.
"""
if name == "Arthur Dent":
return HttpResponse("Hi, Arthur")
else:
return HttpResponse("Howdy, %s" % name)
def nested_view(request):
"""
A view that uses test client to call another view.
"""
c = Client()
c.get("/no_template_view/")
return render(request, "base.html", {"nested": "yes"})
@login_required
def login_protected_redirect_view(request):
"A view that redirects all requests to the GET view"
return HttpResponseRedirect("/get_view/")
def redirect_to_self_with_changing_query_view(request):
query = request.GET.copy()
query["counter"] += "0"
return HttpResponseRedirect(
"/redirect_to_self_with_changing_query_view/?%s" % urlencode(query)
)
def set_session_view(request):
"A view that sets a session variable"
request.session["session_var"] = "YES"
return HttpResponse("set_session")
def check_session_view(request):
"A view that reads a session variable"
return HttpResponse(request.session.get("session_var", "NO"))
def request_methods_view(request):
"A view that responds with the request method"
return HttpResponse("request method: %s" % request.method)
def return_unicode(request):
return render(request, "unicode.html")
def return_undecodable_binary(request):
return HttpResponse(
b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e ReportLab Generated PDF document "
b"http://www.reportlab.com"
)
def return_json_response(request):
content_type = request.GET.get("content_type")
kwargs = {"content_type": content_type} if content_type else {}
return JsonResponse({"key": "value"}, **kwargs)
def return_json_response_latin1(request):
return HttpResponse(
b'{"a":"\xc5"}', content_type="application/json; charset=latin1"
)
def return_text_file(request):
"A view that parses and returns text as a file."
match = CONTENT_TYPE_RE.match(request.META["CONTENT_TYPE"])
if match:
charset = match[1]
else:
charset = settings.DEFAULT_CHARSET
return HttpResponse(
request.body, status=200, content_type="text/plain; charset=%s" % charset
)
def check_headers(request):
"A view that responds with value of the X-ARG-CHECK header"
return HttpResponse(
"HTTP_X_ARG_CHECK: %s" % request.META.get("HTTP_X_ARG_CHECK", "Undefined")
)
def body(request):
"A view that is requested with GET and accesses request.body. Refs #14753."
return HttpResponse(request.body)
def read_all(request):
"A view that is requested with accesses request.read()."
return HttpResponse(request.read())
def read_buffer(request):
"A view that is requested with accesses request.read(LARGE_BUFFER)."
return HttpResponse(request.read(99999))
def request_context_view(request):
# Special attribute that won't be present on a plain HttpRequest
request.special_path = request.path
return render(request, "request_context.html")
def render_template_multiple_times(request):
"""A view that renders a template multiple times."""
return HttpResponse(render_to_string("base.html") + render_to_string("base.html"))
def redirect_based_on_extra_headers_1_view(request):
if "HTTP_REDIRECT" in request.META:
return HttpResponseRedirect("/redirect_based_on_extra_headers_2/")
return HttpResponse()
def redirect_based_on_extra_headers_2_view(request):
if "HTTP_REDIRECT" in request.META:
return HttpResponseRedirect("/redirects/further/more/")
return HttpResponse()
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/models.py | tests/test_client_regress/models.py | from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
from django.db import models
class CustomUser(AbstractBaseUser):
email = models.EmailField(verbose_name="email address", max_length=255, unique=True)
custom_objects = BaseUserManager()
USERNAME_FIELD = "email"
class Meta:
app_label = "test_client_regress"
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/context_processors.py | tests/test_client_regress/context_processors.py | def special(request):
return {"path": request.special_path}
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/auth_backends.py | tests/test_client_regress/auth_backends.py | from django.contrib.auth.backends import ModelBackend
from .models import CustomUser
class CustomUserBackend(ModelBackend):
def authenticate(self, request, username=None, password=None):
try:
user = CustomUser.custom_objects.get_by_natural_key(username)
if user.check_password(password):
return user
except CustomUser.DoesNotExist:
return None
def get_user(self, user_id):
try:
return CustomUser.custom_objects.get(pk=user_id)
except CustomUser.DoesNotExist:
return None
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/__init__.py | tests/test_client_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/test_client_regress/session.py | tests/test_client_regress/session.py | from django.contrib.sessions.backends.base import SessionBase
class SessionStore(SessionBase):
"""
A simple cookie-based session storage implementation.
The session key is actually the session data, pickled and encoded.
This means that saving the session will change the session key.
"""
def __init__(self, session_key=None):
super().__init__(session_key)
def exists(self, session_key):
return False
def create(self):
self._session_key = self.encode({})
def save(self, must_create=False):
self._session_key = self.encode(self._session)
def delete(self, session_key=None):
self._session_key = self.encode({})
def load(self):
try:
return self.decode(self.session_key)
except Exception:
self.modified = True
return {}
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/tests.py | tests/test_client_regress/tests.py | """
Regression tests for the Test Client, especially the customized assertions.
"""
import itertools
import os
from django.contrib.auth.models import User
from django.contrib.auth.signals import user_logged_in, user_logged_out
from django.http import HttpResponse
from django.template import Context, RequestContext, TemplateSyntaxError, engines
from django.template.response import SimpleTemplateResponse
from django.test import (
Client,
SimpleTestCase,
TestCase,
modify_settings,
override_settings,
)
from django.test.client import RedirectCycleError, RequestFactory, encode_file
from django.test.utils import ContextList
from django.urls import NoReverseMatch, reverse
from django.utils.translation import gettext_lazy
from .models import CustomUser
from .views import CustomTestException
class TestDataMixin:
@classmethod
def setUpTestData(cls):
cls.u1 = User.objects.create_user(username="testclient", password="password")
cls.staff = User.objects.create_user(
username="staff", password="password", is_staff=True
)
class ExtraAssertMixin:
def assertRaisesPrefixedMessage(
self,
method,
*method_args,
expected_msg,
msg_prefix="abc",
**method_kwargs,
):
"""
`method` raises an AssertionError with and without a prefixed message.
:param method: The assertion method to test.
:param method_args: Positional arguments to pass to the method.
:param expected_msg: The expected base error message (required
keyword-only).
:param msg_prefix: Optional prefix to be added to the message in the
second subTest.
:param method_kwargs: Keyword arguments to pass to the method.
Used internally for testing Django's assertions.
"""
with (
self.subTest("without prefix"),
self.assertRaisesMessage(AssertionError, expected_msg),
):
method(*method_args, **method_kwargs)
with (
self.subTest("with prefix"),
self.assertRaisesMessage(AssertionError, f"{msg_prefix}: {expected_msg}"),
):
method(*method_args, **method_kwargs, msg_prefix=msg_prefix)
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class AssertContainsTests(ExtraAssertMixin, SimpleTestCase):
def test_basic_contains_not_contains(self):
response = self.client.get("/no_template_view/")
with self.subTest("assertNotContains"):
self.assertNotContains(response, "never")
cases = [
("never", 0),
("once", None),
("once", 1),
("twice", None),
("twice", 2),
]
for text, expected_count in cases:
with self.subTest(text=text, expected_count=expected_count):
if expected_count is not None:
self.assertContains(response, text, count=expected_count)
else:
self.assertContains(response, text)
def test_contains_with_wrong_status_code(self):
response = self.client.get("/no_template_view/")
msg = "Couldn't retrieve content: Response code was 200 (expected 999)"
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"text",
status_code=999,
expected_msg=msg,
)
def test_not_contains_with_wrong_status_code(self):
response = self.client.get("/no_template_view/")
msg = "Couldn't retrieve content: Response code was 200 (expected 999)"
self.assertRaisesPrefixedMessage(
self.assertNotContains,
response,
"text",
status_code=999,
expected_msg=msg,
)
def test_not_contains_failure(self):
response = self.client.get("/no_template_view/")
msg = f"'once' unexpectedly found in the following response\n{response.content}"
self.assertRaisesPrefixedMessage(
self.assertNotContains,
response,
"once",
expected_msg=msg,
)
def test_count_mismatch(self):
response = self.client.get("/no_template_view/")
msg = (
"Found 0 instances of 'never' (expected 1) in the following response\n"
f"{response.content}"
)
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"never",
count=1,
expected_msg=msg,
)
def test_unexpected_presence(self):
response = self.client.get("/no_template_view/")
msg = (
"Found 1 instances of 'once' (expected 0) in the following "
f"response\n{response.content}"
)
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"once",
count=0,
expected_msg=msg,
)
def test_insufficient_count(self):
response = self.client.get("/no_template_view/")
msg = (
"Found 1 instances of 'once' (expected 2) in the following response\n"
f"{response.content}"
)
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"once",
2,
expected_msg=msg,
)
def test_excessive_count(self):
response = self.client.get("/no_template_view/")
msg = (
"Found 2 instances of 'twice' (expected 1) in the following response\n"
f"{response.content}"
)
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"twice",
count=1,
expected_msg=msg,
)
def test_missing_content(self):
response = self.client.get("/no_template_view/")
msg = f"Couldn't find 'thrice' in the following response\n{response.content}"
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"thrice",
expected_msg=msg,
msg_prefix="Custom prexix",
)
def test_missing_content_with_count(self):
response = self.client.get("/no_template_view/")
msg = (
"Found 0 instances of 'thrice' (expected 3) in the following "
f"response\n{response.content}"
)
self.assertRaisesPrefixedMessage(
self.assertContains,
response,
"thrice",
3,
expected_msg=msg,
)
def test_long_content(self):
long_content = (
b"This is a very very very very very very very very long message which "
b"exceeds the max limit of truncation."
)
response = HttpResponse(long_content)
msg = f"Couldn't find 'thrice' in the following response\n{long_content}"
with self.assertRaisesMessage(AssertionError, msg):
self.assertContains(response, "thrice")
msg = (
"Found 1 instances of 'This' (expected 3) in the following response\n"
f"{long_content}"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertContains(response, "This", 3)
msg = f"'very' unexpectedly found in the following response\n{long_content}"
with self.assertRaisesMessage(AssertionError, msg):
self.assertNotContains(response, "very")
def test_unicode_contains(self):
"Unicode characters can be found in template context"
# Regression test for #10183
r = self.client.get("/check_unicode/")
self.assertContains(r, "さかき")
self.assertContains(r, b"\xe5\xb3\xa0".decode())
def test_unicode_not_contains(self):
"""
Unicode characters can be searched for, and not found in template
context
"""
# Regression test for #10183
r = self.client.get("/check_unicode/")
self.assertNotContains(r, "はたけ")
self.assertNotContains(r, b"\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91".decode())
def test_binary_contains(self):
r = self.client.get("/check_binary/")
self.assertContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e")
with self.assertRaises(AssertionError):
self.assertContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e", count=2)
def test_binary_not_contains(self):
r = self.client.get("/check_binary/")
self.assertNotContains(r, b"%ODF-1.4\r\n%\x93\x8c\x8b\x9e")
with self.assertRaises(AssertionError):
self.assertNotContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e")
def test_nontext_contains(self):
r = self.client.get("/no_template_view/")
self.assertContains(r, gettext_lazy("once"))
def test_nontext_not_contains(self):
r = self.client.get("/no_template_view/")
self.assertNotContains(r, gettext_lazy("never"))
def test_assert_contains_renders_template_response(self):
"""
An unrendered SimpleTemplateResponse may be used in assertContains().
"""
template = engines["django"].from_string("Hello")
response = SimpleTemplateResponse(template)
self.assertContains(response, "Hello")
def test_assert_contains_using_non_template_response(self):
"""auto-rendering does not affect responses that aren't
instances (or subclasses) of SimpleTemplateResponse.
Refs #15826.
"""
response = HttpResponse("Hello")
self.assertContains(response, "Hello")
def test_assert_not_contains_renders_template_response(self):
"""
An unrendered SimpleTemplateResponse may be used in
assertNotContains().
"""
template = engines["django"].from_string("Hello")
response = SimpleTemplateResponse(template)
self.assertNotContains(response, "Bye")
def test_assert_not_contains_using_non_template_response(self):
"""
auto-rendering does not affect responses that aren't instances (or
subclasses) of SimpleTemplateResponse.
"""
response = HttpResponse("Hello")
self.assertNotContains(response, "Bye")
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class AssertTemplateUsedTests(TestDataMixin, TestCase):
def test_no_context(self):
"Template usage assertions work then templates aren't in use"
response = self.client.get("/no_template_view/")
# The no template case doesn't mess with the template assertions
self.assertTemplateNotUsed(response, "GET Template")
msg = "No templates used to render the response"
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "GET Template")
msg = "No templates used to render the response"
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "GET Template", msg_prefix="abc")
msg = "No templates used to render the response"
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "GET Template", count=2)
def test_single_context(self):
"Template assertions work when there is a single context"
response = self.client.get("/post_view/", {})
msg = (
": Template 'Empty GET Template' was used unexpectedly in "
"rendering the response"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateNotUsed(response, "Empty GET Template")
with self.assertRaisesMessage(AssertionError, "abc" + msg):
self.assertTemplateNotUsed(response, "Empty GET Template", msg_prefix="abc")
msg = (
": Template 'Empty POST Template' was not a template used to "
"render the response. Actual template(s) used: Empty GET Template"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "Empty POST Template")
with self.assertRaisesMessage(AssertionError, "abc" + msg):
self.assertTemplateUsed(response, "Empty POST Template", msg_prefix="abc")
msg = (
": Template 'Empty GET Template' was expected to be rendered 2 "
"time(s) but was actually rendered 1 time(s)."
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "Empty GET Template", count=2)
with self.assertRaisesMessage(AssertionError, "abc" + msg):
self.assertTemplateUsed(
response, "Empty GET Template", msg_prefix="abc", count=2
)
def test_multiple_context(self):
"Template assertions work when there are multiple contexts"
post_data = {
"text": "Hello World",
"email": "foo@example.com",
"value": 37,
"single": "b",
"multi": ("b", "c", "e"),
}
response = self.client.post("/form_view_with_template/", post_data)
self.assertContains(response, "POST data OK")
msg = "Template '%s' was used unexpectedly in rendering the response"
with self.assertRaisesMessage(AssertionError, msg % "form_view.html"):
self.assertTemplateNotUsed(response, "form_view.html")
with self.assertRaisesMessage(AssertionError, msg % "base.html"):
self.assertTemplateNotUsed(response, "base.html")
msg = (
"Template 'Valid POST Template' was not a template used to render "
"the response. Actual template(s) used: form_view.html, base.html"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "Valid POST Template")
msg = (
"Template 'base.html' was expected to be rendered 2 time(s) but "
"was actually rendered 1 time(s)."
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertTemplateUsed(response, "base.html", count=2)
def test_template_rendered_multiple_times(self):
"""
Template assertions work when a template is rendered multiple times.
"""
response = self.client.get("/render_template_multiple_times/")
self.assertTemplateUsed(response, "base.html", count=2)
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class AssertRedirectsTests(ExtraAssertMixin, SimpleTestCase):
def test_redirect_page(self):
"""
An assertion is raised if the original page couldn't be retrieved as
expected
"""
# This page will redirect with code 301, not 302
response = self.client.get("/permanent_redirect_view/")
msg = (
"Response didn't redirect as expected: Response code was 301 "
"(expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/")
msg = (
"abc: Response didn't redirect as expected: Response code was 301 "
"(expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
def test_followed_redirect_unexpected_initial_status_code(self):
response = self.client.get("/permanent_redirect_view/", follow=True)
msg = (
"Initial response didn't redirect as expected: Response code was 301 "
"(expected 302)"
)
self.assertRaisesPrefixedMessage(
self.assertRedirects,
response,
"/get_view/",
expected_msg=msg,
)
def test_followed_redirect_unexpected_final_status_code(self):
response = self.client.get("/redirect_view/", follow=True)
msg = (
"Response didn't redirect as expected: Final Response code was 200 "
"(expected 403)"
)
self.assertRaisesPrefixedMessage(
self.assertRedirects,
response,
"/get_view/",
status_code=302,
target_status_code=403,
expected_msg=msg,
)
def test_lost_query(self):
"""
An assertion is raised if the redirect location doesn't preserve GET
parameters.
"""
response = self.client.get("/redirect_view/", {"var": "value"})
msg = "Response redirected to '/get_view/?var=value', expected '/get_view/'"
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/")
msg = (
"abc: Response redirected to '/get_view/?var=value', expected '/get_view/'"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
def test_incorrect_target(self):
"An assertion is raised if the response redirects to another target"
response = self.client.get("/permanent_redirect_view/")
msg = (
"Response didn't redirect as expected: Response code was 301 (expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
# Should redirect to get_view
self.assertRedirects(response, "/some_view/")
def test_target_page(self):
"""
An assertion is raised if the response redirect target cannot be
retrieved as expected.
"""
response = self.client.get("/double_redirect_view/")
msg = (
"Couldn't retrieve redirection page '/permanent_redirect_view/': "
"response code was 301 (expected 200)"
)
with self.assertRaisesMessage(AssertionError, msg):
# The redirect target responds with a 301 code, not 200
self.assertRedirects(response, "http://testserver/permanent_redirect_view/")
msg = (
"abc: Couldn't retrieve redirection page '/permanent_redirect_view/': "
"response code was 301 (expected 200)"
)
with self.assertRaisesMessage(AssertionError, msg):
# The redirect target responds with a 301 code, not 200
self.assertRedirects(
response, "http://testserver/permanent_redirect_view/", msg_prefix="abc"
)
def test_redirect_chain(self):
"You can follow a redirect chain of multiple redirects"
response = self.client.get("/redirects/further/more/", {}, follow=True)
self.assertRedirects(
response, "/no_template_view/", status_code=302, target_status_code=200
)
self.assertEqual(len(response.redirect_chain), 1)
self.assertEqual(response.redirect_chain[0], ("/no_template_view/", 302))
def test_multiple_redirect_chain(self):
"You can follow a redirect chain of multiple redirects"
response = self.client.get("/redirects/", {}, follow=True)
self.assertRedirects(
response, "/no_template_view/", status_code=302, target_status_code=200
)
self.assertEqual(len(response.redirect_chain), 3)
self.assertEqual(response.redirect_chain[0], ("/redirects/further/", 302))
self.assertEqual(response.redirect_chain[1], ("/redirects/further/more/", 302))
self.assertEqual(response.redirect_chain[2], ("/no_template_view/", 302))
def test_redirect_chain_to_non_existent(self):
"You can follow a chain to a nonexistent view."
response = self.client.get("/redirect_to_non_existent_view2/", {}, follow=True)
self.assertRedirects(
response, "/non_existent_view/", status_code=302, target_status_code=404
)
def test_redirect_chain_to_self(self):
"Redirections to self are caught and escaped"
with self.assertRaises(RedirectCycleError) as context:
self.client.get("/redirect_to_self/", {}, follow=True)
response = context.exception.last_response
# The chain of redirects stops once the cycle is detected.
self.assertRedirects(
response, "/redirect_to_self/", status_code=302, target_status_code=302
)
self.assertEqual(len(response.redirect_chain), 2)
def test_redirect_to_self_with_changing_query(self):
"Redirections don't loop forever even if query is changing"
with self.assertRaises(RedirectCycleError):
self.client.get(
"/redirect_to_self_with_changing_query_view/",
{"counter": "0"},
follow=True,
)
def test_circular_redirect(self):
"Circular redirect chains are caught and escaped"
with self.assertRaises(RedirectCycleError) as context:
self.client.get("/circular_redirect_1/", {}, follow=True)
response = context.exception.last_response
# The chain of redirects will get back to the starting point, but stop
# there.
self.assertRedirects(
response, "/circular_redirect_2/", status_code=302, target_status_code=302
)
self.assertEqual(len(response.redirect_chain), 4)
def test_redirect_chain_post(self):
"A redirect chain will be followed from an initial POST post"
response = self.client.post("/redirects/", {"nothing": "to_send"}, follow=True)
self.assertRedirects(response, "/no_template_view/", 302, 200)
self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_head(self):
"A redirect chain will be followed from an initial HEAD request"
response = self.client.head("/redirects/", {"nothing": "to_send"}, follow=True)
self.assertRedirects(response, "/no_template_view/", 302, 200)
self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_options(self):
"A redirect chain will be followed from an initial OPTIONS request"
response = self.client.options("/redirects/", follow=True)
self.assertRedirects(response, "/no_template_view/", 302, 200)
self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_put(self):
"A redirect chain will be followed from an initial PUT request"
response = self.client.put("/redirects/", follow=True)
self.assertRedirects(response, "/no_template_view/", 302, 200)
self.assertEqual(len(response.redirect_chain), 3)
def test_redirect_chain_delete(self):
"A redirect chain will be followed from an initial DELETE request"
response = self.client.delete("/redirects/", follow=True)
self.assertRedirects(response, "/no_template_view/", 302, 200)
self.assertEqual(len(response.redirect_chain), 3)
@modify_settings(ALLOWED_HOSTS={"append": "otherserver"})
def test_redirect_to_different_host(self):
"The test client will preserve scheme, host and port changes"
response = self.client.get("/redirect_other_host/", follow=True)
self.assertRedirects(
response,
"https://otherserver:8443/no_template_view/",
status_code=302,
target_status_code=200,
)
# We can't use is_secure() or get_host()
# because response.request is a dictionary, not an HttpRequest
self.assertEqual(response.request.get("wsgi.url_scheme"), "https")
self.assertEqual(response.request.get("SERVER_NAME"), "otherserver")
self.assertEqual(response.request.get("SERVER_PORT"), "8443")
# assertRedirects() can follow redirect to 'otherserver' too.
response = self.client.get("/redirect_other_host/", follow=False)
self.assertRedirects(
response,
"https://otherserver:8443/no_template_view/",
status_code=302,
target_status_code=200,
)
def test_redirect_chain_on_non_redirect_page(self):
"""
An assertion is raised if the original page couldn't be retrieved as
expected.
"""
# This page will redirect with code 301, not 302
response = self.client.get("/get_view/", follow=True)
msg = (
"Response didn't redirect as expected: Response code was 200 (expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/")
msg = (
"abc: Response didn't redirect as expected: Response code was 200 "
"(expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
def test_redirect_on_non_redirect_page(self):
"""
An assertion is raised if the original page couldn't be retrieved as
expected
"""
# This page will redirect with code 301, not 302
response = self.client.get("/get_view/")
msg = (
"Response didn't redirect as expected: Response code was 200 (expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/")
msg = (
"abc: Response didn't redirect as expected: Response code was 200 "
"(expected 302)"
)
with self.assertRaisesMessage(AssertionError, msg):
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
def test_redirect_scheme(self):
"""
An assertion is raised if the response doesn't have the scheme
specified in expected_url.
"""
# For all possible True/False combinations of follow and secure
for follow, secure in itertools.product([True, False], repeat=2):
# always redirects to https
response = self.client.get(
"/https_redirect_view/", follow=follow, secure=secure
)
# the goal scheme is https
self.assertRedirects(
response, "https://testserver/secure_view/", status_code=302
)
with self.assertRaises(AssertionError):
self.assertRedirects(
response, "http://testserver/secure_view/", status_code=302
)
def test_redirect_fetch_redirect_response(self):
"""Preserve extra headers of requests made with django.test.Client."""
methods = (
"get",
"post",
"head",
"options",
"put",
"patch",
"delete",
"trace",
)
for method in methods:
with self.subTest(method=method):
req_method = getattr(self.client, method)
# HTTP_REDIRECT in "extra".
response = req_method(
"/redirect_based_on_extra_headers_1/",
follow=False,
HTTP_REDIRECT="val",
)
self.assertRedirects(
response,
"/redirect_based_on_extra_headers_2/",
fetch_redirect_response=True,
status_code=302,
target_status_code=302,
)
# HTTP_REDIRECT in "headers".
response = req_method(
"/redirect_based_on_extra_headers_1/",
follow=False,
headers={"redirect": "val"},
)
self.assertRedirects(
response,
"/redirect_based_on_extra_headers_2/",
fetch_redirect_response=True,
status_code=302,
target_status_code=302,
)
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class LoginTests(TestDataMixin, TestCase):
def test_login_different_client(self):
"Using a different test client doesn't violate authentication"
# Create a second client, and log in.
c = Client()
login = c.login(username="testclient", password="password")
self.assertTrue(login, "Could not log in")
# Get a redirection page with the second client.
response = c.get("/login_protected_redirect_view/")
# At this points, the self.client isn't logged in.
# assertRedirects uses the original client, not the default client.
self.assertRedirects(response, "/get_view/")
@override_settings(
SESSION_ENGINE="test_client_regress.session",
ROOT_URLCONF="test_client_regress.urls",
)
class SessionEngineTests(TestDataMixin, TestCase):
def test_login(self):
"A session engine that modifies the session key can be used to log in"
login = self.client.login(username="testclient", password="password")
self.assertTrue(login, "Could not log in")
# Try to access a login protected page.
response = self.client.get("/login_protected_view/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context["user"].username, "testclient")
@override_settings(
ROOT_URLCONF="test_client_regress.urls",
)
class URLEscapingTests(SimpleTestCase):
def test_simple_argument_get(self):
"Get a view that has a simple string argument"
response = self.client.get(reverse("arg_view", args=["Slartibartfast"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Howdy, Slartibartfast")
def test_argument_with_space_get(self):
"Get a view that has a string argument that requires escaping"
response = self.client.get(reverse("arg_view", args=["Arthur Dent"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Hi, Arthur")
def test_simple_argument_post(self):
"Post for a view that has a simple string argument"
response = self.client.post(reverse("arg_view", args=["Slartibartfast"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Howdy, Slartibartfast")
def test_argument_with_space_post(self):
"Post for a view that has a string argument that requires escaping"
response = self.client.post(reverse("arg_view", args=["Arthur Dent"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Hi, Arthur")
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class ExceptionTests(TestDataMixin, TestCase):
def test_exception_cleared(self):
"#5836 - A stale user exception isn't re-raised by the test client."
login = self.client.login(username="testclient", password="password")
self.assertTrue(login, "Could not log in")
with self.assertRaises(CustomTestException):
self.client.get("/staff_only/")
# At this point, an exception has been raised, and should be cleared.
# This next operation should be successful; if it isn't we have a
# problem.
login = self.client.login(username="staff", password="password")
self.assertTrue(login, "Could not log in")
self.client.get("/staff_only/")
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class TemplateExceptionTests(SimpleTestCase):
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [os.path.join(os.path.dirname(__file__), "bad_templates")],
}
]
)
def test_bad_404_template(self):
"Errors found when rendering 404 error templates are re-raised"
with self.assertRaises(TemplateSyntaxError):
self.client.get("/no_such_view/")
# We need two different tests to check URLconf substitution - one to check it
# was changed, and another one (without self.urls) to check it was reverted on
# teardown. This pair of tests relies upon the alphabetical ordering of test
# execution.
@override_settings(ROOT_URLCONF="test_client_regress.urls")
class UrlconfSubstitutionTests(SimpleTestCase):
def test_urlconf_was_changed(self):
"TestCase can enforce a custom URLconf on a per-test basis"
url = reverse("arg_view", args=["somename"])
self.assertEqual(url, "/arg_view/somename/")
# This test needs to run *after* UrlconfSubstitutionTests; the zz prefix in the
# name is to ensure alphabetical ordering.
class zzUrlconfSubstitutionTests(SimpleTestCase):
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/test_client_regress/urls.py | tests/test_client_regress/urls.py | from django.urls import include, path
from django.views.generic import RedirectView
from . import views
urlpatterns = [
path("", include("test_client.urls")),
path("no_template_view/", views.no_template_view),
path("staff_only/", views.staff_only_view),
path("get_view/", views.get_view),
path("request_data/", views.request_data),
path(
"request_data_extended/",
views.request_data,
{"template": "extended.html", "data": "bacon"},
),
path("arg_view/<name>/", views.view_with_argument, name="arg_view"),
path("nested_view/", views.nested_view, name="nested_view"),
path("login_protected_redirect_view/", views.login_protected_redirect_view),
path("redirects/", RedirectView.as_view(url="/redirects/further/")),
path("redirects/further/", RedirectView.as_view(url="/redirects/further/more/")),
path("redirects/further/more/", RedirectView.as_view(url="/no_template_view/")),
path(
"redirect_to_non_existent_view/",
RedirectView.as_view(url="/non_existent_view/"),
),
path(
"redirect_to_non_existent_view2/",
RedirectView.as_view(url="/redirect_to_non_existent_view/"),
),
path("redirect_to_self/", RedirectView.as_view(url="/redirect_to_self/")),
path(
"redirect_to_self_with_changing_query_view/",
views.redirect_to_self_with_changing_query_view,
),
path("circular_redirect_1/", RedirectView.as_view(url="/circular_redirect_2/")),
path("circular_redirect_2/", RedirectView.as_view(url="/circular_redirect_3/")),
path("circular_redirect_3/", RedirectView.as_view(url="/circular_redirect_1/")),
path(
"redirect_other_host/",
RedirectView.as_view(url="https://otherserver:8443/no_template_view/"),
),
path(
"redirect_based_on_extra_headers_1/",
views.redirect_based_on_extra_headers_1_view,
),
path(
"redirect_based_on_extra_headers_2/",
views.redirect_based_on_extra_headers_2_view,
),
path("set_session/", views.set_session_view),
path("check_session/", views.check_session_view),
path("request_methods/", views.request_methods_view),
path("check_unicode/", views.return_unicode),
path("check_binary/", views.return_undecodable_binary),
path("json_response/", views.return_json_response),
path("json_response_latin1/", views.return_json_response_latin1),
path("parse_encoded_text/", views.return_text_file),
path("check_headers/", views.check_headers),
path("check_headers_redirect/", RedirectView.as_view(url="/check_headers/")),
path("body/", views.body),
path("read_all/", views.read_all),
path("read_buffer/", views.read_buffer),
path("request_context_view/", views.request_context_view),
path("render_template_multiple_times/", views.render_template_multiple_times),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/generic_relations_regress/models.py | tests/generic_relations_regress/models.py | from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
__all__ = (
"Link",
"Place",
"Restaurant",
"Person",
"Address",
"CharLink",
"TextLink",
"OddRelation1",
"OddRelation2",
"Contact",
"Organization",
"Note",
"Company",
)
class Link(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey()
class LinkProxy(Link):
class Meta:
proxy = True
class Place(models.Model):
name = models.CharField(max_length=100)
links = GenericRelation(Link, related_query_name="places")
link_proxy = GenericRelation(LinkProxy)
class Restaurant(Place):
pass
class Cafe(Restaurant):
pass
class Address(models.Model):
street = models.CharField(max_length=80)
city = models.CharField(max_length=50)
state = models.CharField(max_length=2)
zipcode = models.CharField(max_length=5)
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey()
class Person(models.Model):
account = models.IntegerField(primary_key=True)
name = models.CharField(max_length=128)
addresses = GenericRelation(Address)
class CharLink(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.CharField(max_length=100)
content_object = GenericForeignKey()
value = models.CharField(max_length=250)
class TextLink(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.TextField()
content_object = GenericForeignKey()
value = models.CharField(max_length=250)
class OddRelation1(models.Model):
name = models.CharField(max_length=100)
clinks = GenericRelation(CharLink)
class OddRelation2(models.Model):
name = models.CharField(max_length=100)
tlinks = GenericRelation(TextLink)
# models for test_q_object_or:
class Note(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey()
note = models.TextField()
class Contact(models.Model):
notes = GenericRelation(Note)
class Organization(models.Model):
name = models.CharField(max_length=255)
contacts = models.ManyToManyField(Contact, related_name="organizations")
class Company(models.Model):
name = models.CharField(max_length=100)
links = GenericRelation(Link)
class Team(models.Model):
name = models.CharField(max_length=15)
def __len__(self):
return 0
class Guild(models.Model):
name = models.CharField(max_length=15)
def __bool__(self):
return False
class Tag(models.Model):
content_type = models.ForeignKey(
ContentType, models.CASCADE, related_name="g_r_r_tags"
)
object_id = models.CharField(max_length=15)
content_object = GenericForeignKey()
label = models.CharField(max_length=15)
class Board(models.Model):
name = models.CharField(primary_key=True, max_length=25)
class SpecialGenericRelation(GenericRelation):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.editable = True
self.save_form_data_calls = 0
def save_form_data(self, *args, **kwargs):
self.save_form_data_calls += 1
class HasLinks(models.Model):
links = SpecialGenericRelation(Link, related_query_name="targets")
class Meta:
abstract = True
class HasLinkThing(HasLinks):
pass
class A(models.Model):
flag = models.BooleanField(null=True)
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
class B(models.Model):
a = GenericRelation(A)
class Meta:
ordering = ("id",)
class C(models.Model):
b = models.ForeignKey(B, models.CASCADE)
class Meta:
ordering = ("id",)
class D(models.Model):
b = models.ForeignKey(B, models.SET_NULL, null=True)
class Meta:
ordering = ("id",)
# Ticket #22998
class Node(models.Model):
content_type = models.ForeignKey(ContentType, models.CASCADE)
object_id = models.PositiveIntegerField()
content = GenericForeignKey("content_type", "object_id")
class Content(models.Model):
nodes = GenericRelation(Node)
related_obj = models.ForeignKey("Related", models.CASCADE)
class Related(models.Model):
pass
def prevent_deletes(sender, instance, **kwargs):
raise models.ProtectedError("Not allowed to delete.", [instance])
models.signals.pre_delete.connect(prevent_deletes, sender=Node)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/generic_relations_regress/__init__.py | tests/generic_relations_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/generic_relations_regress/tests.py | tests/generic_relations_regress/tests.py | from django.contrib.contenttypes.models import ContentType
from django.db.models import ProtectedError, Q, Sum
from django.forms.models import modelform_factory
from django.test import TestCase, skipIfDBFeature
from .models import (
A,
Address,
B,
Board,
C,
Cafe,
CharLink,
Company,
Contact,
Content,
D,
Guild,
HasLinkThing,
Link,
Node,
Note,
OddRelation1,
OddRelation2,
Organization,
Person,
Place,
Related,
Restaurant,
Tag,
Team,
TextLink,
)
class GenericRelationTests(TestCase):
def test_inherited_models_content_type(self):
"""
GenericRelations on inherited classes use the correct content type.
"""
p = Place.objects.create(name="South Park")
r = Restaurant.objects.create(name="Chubby's")
l1 = Link.objects.create(content_object=p)
l2 = Link.objects.create(content_object=r)
self.assertEqual(list(p.links.all()), [l1])
self.assertEqual(list(r.links.all()), [l2])
def test_reverse_relation_pk(self):
"""
The correct column name is used for the primary key on the
originating model of a query. See #12664.
"""
p = Person.objects.create(account=23, name="Chef")
Address.objects.create(
street="123 Anywhere Place",
city="Conifer",
state="CO",
zipcode="80433",
content_object=p,
)
qs = Person.objects.filter(addresses__zipcode="80433")
self.assertEqual(1, qs.count())
self.assertEqual("Chef", qs[0].name)
def test_charlink_delete(self):
oddrel = OddRelation1.objects.create(name="clink")
CharLink.objects.create(content_object=oddrel)
oddrel.delete()
def test_textlink_delete(self):
oddrel = OddRelation2.objects.create(name="tlink")
TextLink.objects.create(content_object=oddrel)
oddrel.delete()
def test_charlink_filter(self):
oddrel = OddRelation1.objects.create(name="clink")
CharLink.objects.create(content_object=oddrel, value="value")
self.assertSequenceEqual(
OddRelation1.objects.filter(clinks__value="value"), [oddrel]
)
def test_textlink_filter(self):
oddrel = OddRelation2.objects.create(name="clink")
TextLink.objects.create(content_object=oddrel, value="value")
self.assertSequenceEqual(
OddRelation2.objects.filter(tlinks__value="value"), [oddrel]
)
def test_coerce_object_id_remote_field_cache_persistence(self):
restaurant = Restaurant.objects.create()
CharLink.objects.create(content_object=restaurant)
charlink = CharLink.objects.latest("pk")
self.assertIs(charlink.content_object, charlink.content_object)
# If the model (Cafe) uses more than one level of multi-table
# inheritance.
cafe = Cafe.objects.create()
CharLink.objects.create(content_object=cafe)
charlink = CharLink.objects.latest("pk")
self.assertIs(charlink.content_object, charlink.content_object)
def test_q_object_or(self):
"""
SQL query parameters for generic relations are properly
grouped when OR is used (#11535).
In this bug the first query (below) works while the second, with the
query parameters the same but in reverse order, does not.
The issue is that the generic relation conditions do not get properly
grouped in parentheses.
"""
note_contact = Contact.objects.create()
org_contact = Contact.objects.create()
Note.objects.create(note="note", content_object=note_contact)
org = Organization.objects.create(name="org name")
org.contacts.add(org_contact)
# search with a non-matching note and a matching org name
qs = Contact.objects.filter(
Q(notes__note__icontains=r"other note")
| Q(organizations__name__icontains=r"org name")
)
self.assertIn(org_contact, qs)
# search again, with the same query parameters, in reverse order
qs = Contact.objects.filter(
Q(organizations__name__icontains=r"org name")
| Q(notes__note__icontains=r"other note")
)
self.assertIn(org_contact, qs)
def test_join_reuse(self):
qs = Person.objects.filter(addresses__street="foo").filter(
addresses__street="bar"
)
self.assertEqual(str(qs.query).count("JOIN"), 2)
def test_generic_relation_ordering(self):
"""
Ordering over a generic relation does not include extraneous
duplicate results, nor excludes rows not participating in the relation.
"""
p1 = Place.objects.create(name="South Park")
p2 = Place.objects.create(name="The City")
c = Company.objects.create(name="Chubby's Intl.")
Link.objects.create(content_object=p1)
Link.objects.create(content_object=c)
places = list(Place.objects.order_by("links__id"))
def count_places(place):
return len([p for p in places if p.id == place.id])
self.assertEqual(len(places), 2)
self.assertEqual(count_places(p1), 1)
self.assertEqual(count_places(p2), 1)
def test_target_model_len_zero(self):
"""
Saving a model with a GenericForeignKey to a model instance whose
__len__ method returns 0 (Team.__len__() here) shouldn't fail (#13085).
"""
team1 = Team.objects.create(name="Backend devs")
note = Note(note="Deserve a bonus", content_object=team1)
note.save()
def test_target_model_bool_false(self):
"""
Saving a model with a GenericForeignKey to a model instance whose
__bool__ method returns False (Guild.__bool__() here) shouldn't fail
(#13085).
"""
g1 = Guild.objects.create(name="First guild")
note = Note(note="Note for guild", content_object=g1)
note.save()
@skipIfDBFeature("interprets_empty_strings_as_nulls")
def test_gfk_to_model_with_empty_pk(self):
"""Test related to #13085"""
# Saving model with GenericForeignKey to model instance with an
# empty CharField PK
b1 = Board.objects.create(name="")
tag = Tag(label="VP", content_object=b1)
tag.save()
def test_ticket_20378(self):
# Create a couple of extra HasLinkThing so that the autopk value
# isn't the same for Link and HasLinkThing.
hs1 = HasLinkThing.objects.create()
hs2 = HasLinkThing.objects.create()
hs3 = HasLinkThing.objects.create()
hs4 = HasLinkThing.objects.create()
l1 = Link.objects.create(content_object=hs3)
l2 = Link.objects.create(content_object=hs4)
self.assertSequenceEqual(HasLinkThing.objects.filter(links=l1), [hs3])
self.assertSequenceEqual(HasLinkThing.objects.filter(links=l2), [hs4])
self.assertSequenceEqual(
HasLinkThing.objects.exclude(links=l2), [hs1, hs2, hs3]
)
self.assertSequenceEqual(
HasLinkThing.objects.exclude(links=l1), [hs1, hs2, hs4]
)
def test_ticket_20564(self):
b1 = B.objects.create()
b2 = B.objects.create()
b3 = B.objects.create()
c1 = C.objects.create(b=b1)
c2 = C.objects.create(b=b2)
c3 = C.objects.create(b=b3)
A.objects.create(flag=None, content_object=b1)
A.objects.create(flag=True, content_object=b2)
self.assertSequenceEqual(C.objects.filter(b__a__flag=None), [c1, c3])
self.assertSequenceEqual(C.objects.exclude(b__a__flag=None), [c2])
def test_ticket_20564_nullable_fk(self):
b1 = B.objects.create()
b2 = B.objects.create()
b3 = B.objects.create()
d1 = D.objects.create(b=b1)
d2 = D.objects.create(b=b2)
d3 = D.objects.create(b=b3)
d4 = D.objects.create()
A.objects.create(flag=None, content_object=b1)
A.objects.create(flag=True, content_object=b1)
A.objects.create(flag=True, content_object=b2)
self.assertSequenceEqual(D.objects.exclude(b__a__flag=None), [d2])
self.assertSequenceEqual(D.objects.filter(b__a__flag=None), [d1, d3, d4])
self.assertSequenceEqual(B.objects.filter(a__flag=None), [b1, b3])
self.assertSequenceEqual(B.objects.exclude(a__flag=None), [b2])
def test_extra_join_condition(self):
# A crude check that content_type_id is taken in account in the
# join/subquery condition.
self.assertIn(
"content_type_id", str(B.objects.exclude(a__flag=None).query).lower()
)
# No need for any joins - the join from inner query can be trimmed in
# this case (but not in the above case as no a objects at all for given
# B would then fail).
self.assertNotIn(" join ", str(B.objects.exclude(a__flag=True).query).lower())
self.assertIn(
"content_type_id", str(B.objects.exclude(a__flag=True).query).lower()
)
def test_annotate(self):
hs1 = HasLinkThing.objects.create()
hs2 = HasLinkThing.objects.create()
HasLinkThing.objects.create()
b = Board.objects.create(name=str(hs1.pk))
Link.objects.create(content_object=hs2)
link = Link.objects.create(content_object=hs1)
Link.objects.create(content_object=b)
qs = HasLinkThing.objects.annotate(Sum("links")).filter(pk=hs1.pk)
# If content_type restriction isn't in the query's join condition,
# then wrong results are produced here as the link to b will also match
# (b and hs1 have equal pks).
self.assertEqual(qs.count(), 1)
self.assertEqual(qs[0].links__sum, link.id)
link.delete()
# Now if we don't have proper left join, we will not produce any
# results at all here.
# clear cached results
qs = qs.all()
self.assertEqual(qs.count(), 1)
# Note - 0 here would be a nicer result...
self.assertIs(qs[0].links__sum, None)
# Finally test that filtering works.
self.assertEqual(qs.filter(links__sum__isnull=True).count(), 1)
self.assertEqual(qs.filter(links__sum__isnull=False).count(), 0)
def test_filter_targets_related_pk(self):
# Use hardcoded PKs to ensure different PKs for "link" and "hs2"
# objects.
HasLinkThing.objects.create(pk=1)
hs2 = HasLinkThing.objects.create(pk=2)
link = Link.objects.create(content_object=hs2, pk=1)
self.assertNotEqual(link.object_id, link.pk)
self.assertSequenceEqual(HasLinkThing.objects.filter(links=link.pk), [hs2])
def test_editable_generic_rel(self):
GenericRelationForm = modelform_factory(HasLinkThing, fields="__all__")
form = GenericRelationForm()
self.assertIn("links", form.fields)
form = GenericRelationForm({"links": None})
self.assertTrue(form.is_valid())
form.save()
links = HasLinkThing._meta.get_field("links")
self.assertEqual(links.save_form_data_calls, 1)
def test_ticket_22998(self):
related = Related.objects.create()
content = Content.objects.create(related_obj=related)
Node.objects.create(content=content)
# deleting the Related cascades to the Content cascades to the Node,
# where the pre_delete signal should fire and prevent deletion.
with self.assertRaises(ProtectedError):
related.delete()
def test_ticket_22982(self):
place = Place.objects.create(name="My Place")
self.assertIn("GenericRelatedObjectManager", str(place.links))
def test_filter_on_related_proxy_model(self):
place = Place.objects.create()
Link.objects.create(content_object=place)
self.assertEqual(Place.objects.get(link_proxy__object_id=place.id), place)
def test_generic_reverse_relation_with_mti(self):
"""
Filtering with a reverse generic relation, where the GenericRelation
comes from multi-table inheritance.
"""
place = Place.objects.create(name="Test Place")
link = Link.objects.create(content_object=place)
result = Link.objects.filter(places=place)
self.assertCountEqual(result, [link])
def test_generic_reverse_relation_with_abc(self):
"""
The reverse generic relation accessor (targets) is created if the
GenericRelation comes from an abstract base model (HasLinks).
"""
thing = HasLinkThing.objects.create()
link = Link.objects.create(content_object=thing)
self.assertCountEqual(link.targets.all(), [thing])
def test_generic_reverse_relation_exclude_filter(self):
place1 = Place.objects.create(name="Test Place 1")
place2 = Place.objects.create(name="Test Place 2")
Link.objects.create(content_object=place1)
link2 = Link.objects.create(content_object=place2)
qs = Link.objects.filter(~Q(places__name="Test Place 1"))
self.assertSequenceEqual(qs, [link2])
qs = Link.objects.exclude(places__name="Test Place 1")
self.assertSequenceEqual(qs, [link2])
def test_check_cached_value_pk_different_type(self):
"""Primary key is not checked if the content type doesn't match."""
board = Board.objects.create(name="some test")
oddrel = OddRelation1.objects.create(name="clink")
charlink = CharLink.objects.create(content_object=oddrel)
charlink = CharLink.objects.get(pk=charlink.pk)
self.assertEqual(charlink.content_object, oddrel)
charlink.object_id = board.pk
charlink.content_type_id = ContentType.objects.get_for_model(Board).id
self.assertEqual(charlink.content_object, board)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/select_for_update/models.py | tests/select_for_update/models.py | from django.db import models
class Entity(models.Model):
pass
class Country(Entity):
name = models.CharField(max_length=30)
class EUCountry(Country):
join_date = models.DateField()
class City(models.Model):
name = models.CharField(max_length=30)
country = models.ForeignKey(Country, models.CASCADE)
class EUCity(models.Model):
name = models.CharField(max_length=30)
country = models.ForeignKey(EUCountry, models.CASCADE)
class CountryProxy(Country):
class Meta:
proxy = True
class CountryProxyProxy(CountryProxy):
class Meta:
proxy = True
class CityCountryProxy(models.Model):
country = models.ForeignKey(CountryProxyProxy, models.CASCADE)
class Person(models.Model):
name = models.CharField(max_length=30)
born = models.ForeignKey(City, models.CASCADE, related_name="+")
died = models.ForeignKey(City, models.CASCADE, related_name="+")
class PersonProfile(models.Model):
person = models.OneToOneField(Person, models.CASCADE, related_name="profile")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/select_for_update/__init__.py | tests/select_for_update/__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_for_update/tests.py | tests/select_for_update/tests.py | import threading
import time
from unittest import mock
from multiple_database.routers import TestRouter
from django.core.exceptions import FieldError
from django.db import (
DatabaseError,
NotSupportedError,
connection,
connections,
router,
transaction,
)
from django.db.models import F, Value
from django.db.models.functions import Concat
from django.test import (
TransactionTestCase,
override_settings,
skipIfDBFeature,
skipUnlessDBFeature,
)
from django.test.utils import CaptureQueriesContext
from .models import (
City,
CityCountryProxy,
Country,
EUCity,
EUCountry,
Person,
PersonProfile,
)
class SelectForUpdateTests(TransactionTestCase):
available_apps = ["select_for_update"]
def setUp(self):
# This is executed in autocommit mode so that code in
# run_select_for_update can see this data.
self.country1 = Country.objects.create(name="Belgium")
self.country2 = Country.objects.create(name="France")
self.city1 = City.objects.create(name="Liberchies", country=self.country1)
self.city2 = City.objects.create(name="Samois-sur-Seine", country=self.country2)
self.person = Person.objects.create(
name="Reinhardt", born=self.city1, died=self.city2
)
self.person_profile = PersonProfile.objects.create(person=self.person)
# We need another database connection in transaction to test that one
# connection issuing a SELECT ... FOR UPDATE will block.
self.new_connection = connection.copy()
def tearDown(self):
try:
self.end_blocking_transaction()
except (DatabaseError, AttributeError):
pass
self.new_connection.close()
def start_blocking_transaction(self):
self.new_connection.set_autocommit(False)
# Start a blocking transaction. At some point,
# end_blocking_transaction() should be called.
self.cursor = self.new_connection.cursor()
sql = "SELECT * FROM %(db_table)s %(for_update)s;" % {
"db_table": Person._meta.db_table,
"for_update": self.new_connection.ops.for_update_sql(),
}
self.cursor.execute(sql, ())
self.cursor.fetchone()
def end_blocking_transaction(self):
# Roll back the blocking transaction.
self.cursor.close()
self.new_connection.rollback()
self.new_connection.set_autocommit(True)
def has_for_update_sql(self, queries, **kwargs):
# Examine the SQL that was executed to determine whether it
# contains the 'SELECT..FOR UPDATE' stanza.
for_update_sql = connection.ops.for_update_sql(**kwargs)
return any(for_update_sql in query["sql"] for query in queries)
@skipUnlessDBFeature("has_select_for_update")
def test_for_update_sql_generated(self):
"""
The backend's FOR UPDATE variant appears in
generated SQL when select_for_update is invoked.
"""
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(Person.objects.select_for_update())
self.assertTrue(self.has_for_update_sql(ctx.captured_queries))
@skipUnlessDBFeature("has_select_for_update_nowait")
def test_for_update_sql_generated_nowait(self):
"""
The backend's FOR UPDATE NOWAIT variant appears in
generated SQL when select_for_update is invoked.
"""
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(Person.objects.select_for_update(nowait=True))
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, nowait=True))
@skipUnlessDBFeature("has_select_for_update_skip_locked")
def test_for_update_sql_generated_skip_locked(self):
"""
The backend's FOR UPDATE SKIP LOCKED variant appears in
generated SQL when select_for_update is invoked.
"""
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(Person.objects.select_for_update(skip_locked=True))
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, skip_locked=True))
@skipUnlessDBFeature("has_select_for_no_key_update")
def test_update_sql_generated_no_key(self):
"""
The backend's FOR NO KEY UPDATE variant appears in generated SQL when
select_for_update() is invoked.
"""
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(Person.objects.select_for_update(no_key=True))
self.assertIs(self.has_for_update_sql(ctx.captured_queries, no_key=True), True)
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_generated_of(self):
"""
The backend's FOR UPDATE OF variant appears in the generated SQL when
select_for_update() is invoked.
"""
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
Person.objects.select_related(
"born__country",
)
.select_for_update(
of=("born__country",),
)
.select_for_update(of=("self", "born__country"))
)
features = connections["default"].features
if features.select_for_update_of_column:
expected = [
'select_for_update_person"."id',
'select_for_update_country"."entity_ptr_id',
]
else:
expected = ["select_for_update_person", "select_for_update_country"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_of_values_list(self):
queries = Person.objects.select_for_update(
of=("self",),
).values_list(Concat(Value("Dr. "), F("name")), "born")
with transaction.atomic():
values = queries.get(pk=self.person.pk)
self.assertSequenceEqual(values, ("Dr. Reinhardt", self.city1.pk))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_model_inheritance_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(EUCountry.objects.select_for_update(of=("self",)))
if connection.features.select_for_update_of_column:
expected = ['select_for_update_eucountry"."country_ptr_id']
else:
expected = ["select_for_update_eucountry"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_model_inheritance_ptr_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
EUCountry.objects.select_for_update(
of=(
"self",
"country_ptr",
)
)
)
if connection.features.select_for_update_of_column:
expected = [
'select_for_update_eucountry"."country_ptr_id',
'select_for_update_country"."entity_ptr_id',
]
else:
expected = ["select_for_update_eucountry", "select_for_update_country"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_related_model_inheritance_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
EUCity.objects.select_related("country").select_for_update(
of=("self", "country"),
)
)
if connection.features.select_for_update_of_column:
expected = [
'select_for_update_eucity"."id',
'select_for_update_eucountry"."country_ptr_id',
]
else:
expected = ["select_for_update_eucity", "select_for_update_eucountry"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_model_inheritance_nested_ptr_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
EUCity.objects.select_related("country").select_for_update(
of=(
"self",
"country__country_ptr",
),
)
)
if connection.features.select_for_update_of_column:
expected = [
'select_for_update_eucity"."id',
'select_for_update_country"."entity_ptr_id',
]
else:
expected = ["select_for_update_eucity", "select_for_update_country"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_multilevel_model_inheritance_ptr_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
EUCountry.objects.select_for_update(
of=("country_ptr", "country_ptr__entity_ptr"),
)
)
if connection.features.select_for_update_of_column:
expected = [
'select_for_update_country"."entity_ptr_id',
'select_for_update_entity"."id',
]
else:
expected = ["select_for_update_country", "select_for_update_entity"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_sql_model_proxy_generated_of(self):
with transaction.atomic(), CaptureQueriesContext(connection) as ctx:
list(
CityCountryProxy.objects.select_related("country").select_for_update(
of=("country",),
)
)
if connection.features.select_for_update_of_column:
expected = ['select_for_update_country"."entity_ptr_id']
else:
expected = ["select_for_update_country"]
expected = [connection.ops.quote_name(value) for value in expected]
self.assertTrue(self.has_for_update_sql(ctx.captured_queries, of=expected))
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_of_followed_by_values(self):
with transaction.atomic():
values = list(Person.objects.select_for_update(of=("self",)).values("pk"))
self.assertEqual(values, [{"pk": self.person.pk}])
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_of_followed_by_values_list(self):
with transaction.atomic():
values = list(
Person.objects.select_for_update(of=("self",)).values_list("pk")
)
self.assertEqual(values, [(self.person.pk,)])
@skipUnlessDBFeature("has_select_for_update_of")
def test_for_update_of_self_when_self_is_not_selected(self):
"""
select_for_update(of=['self']) when the only columns selected are from
related tables.
"""
with transaction.atomic():
values = list(
Person.objects.select_related("born")
.select_for_update(of=("self",))
.values("born__name")
)
self.assertEqual(values, [{"born__name": self.city1.name}])
@skipUnlessDBFeature(
"has_select_for_update_of",
"supports_select_for_update_with_limit",
)
def test_for_update_of_with_exists(self):
with transaction.atomic():
qs = Person.objects.select_for_update(of=("self", "born"))
self.assertIs(qs.exists(), True)
@skipUnlessDBFeature("has_select_for_update_nowait", "supports_transactions")
def test_nowait_raises_error_on_block(self):
"""
If nowait is specified, we expect an error to be raised rather
than blocking.
"""
self.start_blocking_transaction()
status = []
thread = threading.Thread(
target=self.run_select_for_update,
args=(status,),
kwargs={"nowait": True},
)
thread.start()
time.sleep(1)
thread.join()
self.end_blocking_transaction()
self.assertIsInstance(status[-1], DatabaseError)
@skipUnlessDBFeature("has_select_for_update_skip_locked", "supports_transactions")
def test_skip_locked_skips_locked_rows(self):
"""
If skip_locked is specified, the locked row is skipped resulting in
Person.DoesNotExist.
"""
self.start_blocking_transaction()
status = []
thread = threading.Thread(
target=self.run_select_for_update,
args=(status,),
kwargs={"skip_locked": True},
)
thread.start()
time.sleep(1)
thread.join()
self.end_blocking_transaction()
self.assertIsInstance(status[-1], Person.DoesNotExist)
@skipIfDBFeature("has_select_for_update_nowait")
@skipUnlessDBFeature("has_select_for_update")
def test_unsupported_nowait_raises_error(self):
"""
NotSupportedError is raised if a SELECT...FOR UPDATE NOWAIT is run on
a database backend that supports FOR UPDATE but not NOWAIT.
"""
with self.assertRaisesMessage(
NotSupportedError, "NOWAIT is not supported on this database backend."
):
with transaction.atomic():
Person.objects.select_for_update(nowait=True).get()
@skipIfDBFeature("has_select_for_update_skip_locked")
@skipUnlessDBFeature("has_select_for_update")
def test_unsupported_skip_locked_raises_error(self):
"""
NotSupportedError is raised if a SELECT...FOR UPDATE SKIP LOCKED is run
on a database backend that supports FOR UPDATE but not SKIP LOCKED.
"""
with self.assertRaisesMessage(
NotSupportedError, "SKIP LOCKED is not supported on this database backend."
):
with transaction.atomic():
Person.objects.select_for_update(skip_locked=True).get()
@skipIfDBFeature("has_select_for_update_of")
@skipUnlessDBFeature("has_select_for_update")
def test_unsupported_of_raises_error(self):
"""
NotSupportedError is raised if a SELECT...FOR UPDATE OF... is run on
a database backend that supports FOR UPDATE but not OF.
"""
msg = "FOR UPDATE OF is not supported on this database backend."
with self.assertRaisesMessage(NotSupportedError, msg):
with transaction.atomic():
Person.objects.select_for_update(of=("self",)).get()
@skipIfDBFeature("has_select_for_no_key_update")
@skipUnlessDBFeature("has_select_for_update")
def test_unsuported_no_key_raises_error(self):
"""
NotSupportedError is raised if a SELECT...FOR NO KEY UPDATE... is run
on a database backend that supports FOR UPDATE but not NO KEY.
"""
msg = "FOR NO KEY UPDATE is not supported on this database backend."
with self.assertRaisesMessage(NotSupportedError, msg):
with transaction.atomic():
Person.objects.select_for_update(no_key=True).get()
@skipUnlessDBFeature("has_select_for_update", "has_select_for_update_of")
def test_unrelated_of_argument_raises_error(self):
"""
FieldError is raised if a non-relation field is specified in of=(...).
"""
msg = (
"Invalid field name(s) given in select_for_update(of=(...)): %s. "
"Only relational fields followed in the query are allowed. "
"Choices are: self, born, born__country, "
"born__country__entity_ptr."
)
invalid_of = [
("nonexistent",),
("name",),
("born__nonexistent",),
("born__name",),
("born__nonexistent", "born__name"),
]
for of in invalid_of:
with self.subTest(of=of):
with self.assertRaisesMessage(FieldError, msg % ", ".join(of)):
with transaction.atomic():
Person.objects.select_related(
"born__country"
).select_for_update(of=of).get()
@skipUnlessDBFeature("has_select_for_update", "has_select_for_update_of")
def test_related_but_unselected_of_argument_raises_error(self):
"""
FieldError is raised if a relation field that is not followed in the
query is specified in of=(...).
"""
msg = (
"Invalid field name(s) given in select_for_update(of=(...)): %s. "
"Only relational fields followed in the query are allowed. "
"Choices are: self, born, profile."
)
for name in ["born__country", "died", "died__country"]:
with self.subTest(name=name):
with self.assertRaisesMessage(FieldError, msg % name):
with transaction.atomic():
Person.objects.select_related("born", "profile").exclude(
profile=None
).select_for_update(of=(name,)).get()
@skipUnlessDBFeature("has_select_for_update", "has_select_for_update_of")
def test_model_inheritance_of_argument_raises_error_ptr_in_choices(self):
msg = (
"Invalid field name(s) given in select_for_update(of=(...)): "
"name. Only relational fields followed in the query are allowed. "
"Choices are: self, %s."
)
with self.assertRaisesMessage(
FieldError,
msg % "country, country__country_ptr, country__country_ptr__entity_ptr",
):
with transaction.atomic():
EUCity.objects.select_related(
"country",
).select_for_update(of=("name",)).get()
with self.assertRaisesMessage(
FieldError, msg % "country_ptr, country_ptr__entity_ptr"
):
with transaction.atomic():
EUCountry.objects.select_for_update(of=("name",)).get()
@skipUnlessDBFeature("has_select_for_update", "has_select_for_update_of")
def test_model_proxy_of_argument_raises_error_proxy_field_in_choices(self):
msg = (
"Invalid field name(s) given in select_for_update(of=(...)): "
"name. Only relational fields followed in the query are allowed. "
"Choices are: self, country, country__entity_ptr."
)
with self.assertRaisesMessage(FieldError, msg):
with transaction.atomic():
CityCountryProxy.objects.select_related(
"country",
).select_for_update(of=("name",)).get()
@skipUnlessDBFeature("has_select_for_update", "has_select_for_update_of")
def test_reverse_one_to_one_of_arguments(self):
"""
Reverse OneToOneFields may be included in of=(...) as long as NULLs
are excluded because LEFT JOIN isn't allowed in SELECT FOR UPDATE.
"""
with transaction.atomic():
person = (
Person.objects.select_related(
"profile",
)
.exclude(profile=None)
.select_for_update(of=("profile",))
.get()
)
self.assertEqual(person.profile, self.person_profile)
@skipUnlessDBFeature("has_select_for_update")
def test_for_update_after_from(self):
features_class = connections["default"].features.__class__
attribute_to_patch = "%s.%s.for_update_after_from" % (
features_class.__module__,
features_class.__name__,
)
with mock.patch(attribute_to_patch, return_value=True):
with transaction.atomic():
self.assertIn(
"FOR UPDATE WHERE",
str(Person.objects.filter(name="foo").select_for_update().query),
)
@skipUnlessDBFeature("has_select_for_update", "supports_transactions")
def test_for_update_requires_transaction(self):
"""
A TransactionManagementError is raised
when a select_for_update query is executed outside of a transaction.
"""
msg = "select_for_update cannot be used outside of a transaction."
with self.assertRaisesMessage(transaction.TransactionManagementError, msg):
list(Person.objects.select_for_update())
@skipUnlessDBFeature("has_select_for_update", "supports_transactions")
def test_for_update_requires_transaction_only_in_execution(self):
"""
No TransactionManagementError is raised
when select_for_update is invoked outside of a transaction -
only when the query is executed.
"""
people = Person.objects.select_for_update()
msg = "select_for_update cannot be used outside of a transaction."
with self.assertRaisesMessage(transaction.TransactionManagementError, msg):
list(people)
@skipUnlessDBFeature("supports_select_for_update_with_limit")
def test_select_for_update_with_limit(self):
other = Person.objects.create(name="Grappeli", born=self.city1, died=self.city2)
with transaction.atomic():
qs = list(Person.objects.order_by("pk").select_for_update()[1:2])
self.assertEqual(qs[0], other)
@skipIfDBFeature("supports_select_for_update_with_limit")
def test_unsupported_select_for_update_with_limit(self):
msg = (
"LIMIT/OFFSET is not supported with select_for_update on this database "
"backend."
)
with self.assertRaisesMessage(NotSupportedError, msg):
with transaction.atomic():
list(Person.objects.order_by("pk").select_for_update()[1:2])
def run_select_for_update(self, status, **kwargs):
"""
Utility method that runs a SELECT FOR UPDATE against all
Person instances. After the select_for_update, it attempts
to update the name of the only record, save, and commit.
This function expects to run in a separate thread.
"""
status.append("started")
try:
# We need to enter transaction management again, as this is done on
# per-thread basis
with transaction.atomic():
person = Person.objects.select_for_update(**kwargs).get()
person.name = "Fred"
person.save()
except (DatabaseError, Person.DoesNotExist) as e:
status.append(e)
finally:
# This method is run in a separate thread. It uses its own
# database connection. Close it without waiting for the GC.
connection.close()
@skipUnlessDBFeature("has_select_for_update")
@skipUnlessDBFeature("supports_transactions")
def test_block(self):
"""
A thread running a select_for_update that accesses rows being touched
by a similar operation on another connection blocks correctly.
"""
# First, let's start the transaction in our thread.
self.start_blocking_transaction()
# Now, try it again using the ORM's select_for_update
# facility. Do this in a separate thread.
status = []
thread = threading.Thread(target=self.run_select_for_update, args=(status,))
# The thread should immediately block, but we'll sleep
# for a bit to make sure.
thread.start()
sanity_count = 0
while len(status) != 1 and sanity_count < 10:
sanity_count += 1
time.sleep(1)
if sanity_count >= 10:
raise ValueError("Thread did not run and block")
# Check the person hasn't been updated. Since this isn't
# using FOR UPDATE, it won't block.
p = Person.objects.get(pk=self.person.pk)
self.assertEqual("Reinhardt", p.name)
# When we end our blocking transaction, our thread should
# be able to continue.
self.end_blocking_transaction()
thread.join(5.0)
# Check the thread has finished. Assuming it has, we should
# find that it has updated the person's name.
self.assertFalse(thread.is_alive())
# We must commit the transaction to ensure that MySQL gets a fresh
# read, since by default it runs in REPEATABLE READ mode
transaction.commit()
p = Person.objects.get(pk=self.person.pk)
self.assertEqual("Fred", p.name)
@skipUnlessDBFeature("has_select_for_update", "supports_transactions")
def test_raw_lock_not_available(self):
"""
Running a raw query which can't obtain a FOR UPDATE lock raises
the correct exception
"""
self.start_blocking_transaction()
def raw(status):
try:
list(
Person.objects.raw(
"SELECT * FROM %s %s"
% (
Person._meta.db_table,
connection.ops.for_update_sql(nowait=True),
)
)
)
except DatabaseError as e:
status.append(e)
finally:
# This method is run in a separate thread. It uses its own
# database connection. Close it without waiting for the GC.
# Connection cannot be closed on Oracle because cursor is still
# open.
if connection.vendor != "oracle":
connection.close()
status = []
thread = threading.Thread(target=raw, kwargs={"status": status})
thread.start()
time.sleep(1)
thread.join()
self.end_blocking_transaction()
self.assertIsInstance(status[-1], DatabaseError)
@skipUnlessDBFeature("has_select_for_update")
@override_settings(DATABASE_ROUTERS=[TestRouter()])
def test_select_for_update_on_multidb(self):
query = Person.objects.select_for_update()
self.assertEqual(router.db_for_write(Person), query.db)
@skipUnlessDBFeature("has_select_for_update")
def test_select_for_update_with_get(self):
with transaction.atomic():
person = Person.objects.select_for_update().get(name="Reinhardt")
self.assertEqual(person.name, "Reinhardt")
def test_nowait_and_skip_locked(self):
with self.assertRaisesMessage(
ValueError, "The nowait option cannot be used with skip_locked."
):
Person.objects.select_for_update(nowait=True, skip_locked=True)
def test_ordered_select_for_update(self):
"""
Subqueries should respect ordering as an ORDER BY clause may be useful
to specify a row locking order to prevent deadlocks (#27193).
"""
with transaction.atomic():
qs = Person.objects.filter(
id__in=Person.objects.order_by("-id").select_for_update()
)
self.assertIn("ORDER BY", str(qs.query))
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/reverse_lookup/models.py | tests/reverse_lookup/models.py | """
Reverse lookups
This demonstrates the reverse lookup features of the database API.
"""
from django.db import models
class User(models.Model):
name = models.CharField(max_length=200)
class Poll(models.Model):
question = models.CharField(max_length=200)
creator = models.ForeignKey(User, models.CASCADE)
class Choice(models.Model):
name = models.CharField(max_length=100)
poll = models.ForeignKey(Poll, models.CASCADE, related_name="poll_choice")
related_poll = models.ForeignKey(
Poll, models.CASCADE, related_name="related_choice"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/reverse_lookup/__init__.py | tests/reverse_lookup/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/reverse_lookup/tests.py | tests/reverse_lookup/tests.py | from django.core.exceptions import FieldError
from django.test import TestCase
from .models import Choice, Poll, User
class ReverseLookupTests(TestCase):
@classmethod
def setUpTestData(cls):
john = User.objects.create(name="John Doe")
jim = User.objects.create(name="Jim Bo")
first_poll = Poll.objects.create(
question="What's the first question?", creator=john
)
second_poll = Poll.objects.create(
question="What's the second question?", creator=jim
)
Choice.objects.create(
poll=first_poll, related_poll=second_poll, name="This is the answer."
)
def test_reverse_by_field(self):
u1 = User.objects.get(poll__question__exact="What's the first question?")
self.assertEqual(u1.name, "John Doe")
u2 = User.objects.get(poll__question__exact="What's the second question?")
self.assertEqual(u2.name, "Jim Bo")
def test_reverse_by_related_name(self):
p1 = Poll.objects.get(poll_choice__name__exact="This is the answer.")
self.assertEqual(p1.question, "What's the first question?")
p2 = Poll.objects.get(related_choice__name__exact="This is the answer.")
self.assertEqual(p2.question, "What's the second question?")
def test_reverse_field_name_disallowed(self):
"""
If a related_name is given you can't use the field name instead
"""
msg = (
"Cannot resolve keyword 'choice' into field. Choices are: "
"creator, creator_id, id, poll_choice, question, related_choice"
)
with self.assertRaisesMessage(FieldError, msg):
Poll.objects.get(choice__name__exact="This is the answer")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/signing/__init__.py | tests/signing/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/signing/tests.py | tests/signing/tests.py | import datetime
from django.core import signing
from django.test import SimpleTestCase, override_settings
from django.test.utils import freeze_time
from django.utils.crypto import InvalidAlgorithm
class TestSigner(SimpleTestCase):
def test_signature(self):
"signature() method should generate a signature"
signer = signing.Signer(key="predictable-secret")
signer2 = signing.Signer(key="predictable-secret2")
for s in (
b"hello",
b"3098247:529:087:",
"\u2019".encode(),
):
self.assertEqual(
signer.signature(s),
signing.base64_hmac(
signer.salt + "signer",
s,
"predictable-secret",
algorithm=signer.algorithm,
),
)
self.assertNotEqual(signer.signature(s), signer2.signature(s))
def test_signature_with_salt(self):
signer = signing.Signer(key="predictable-secret", salt="extra-salt")
self.assertEqual(
signer.signature("hello"),
signing.base64_hmac(
"extra-salt" + "signer",
"hello",
"predictable-secret",
algorithm=signer.algorithm,
),
)
self.assertNotEqual(
signing.Signer(key="predictable-secret", salt="one").signature("hello"),
signing.Signer(key="predictable-secret", salt="two").signature("hello"),
)
def test_custom_algorithm(self):
signer = signing.Signer(key="predictable-secret", algorithm="sha512")
self.assertEqual(
signer.signature("hello"),
"Usf3uVQOZ9m6uPfVonKR-EBXjPe7bjMbp3_Fq8MfsptgkkM1ojidN0BxYaT5HAEN1"
"VzO9_jVu7R-VkqknHYNvw",
)
def test_invalid_algorithm(self):
signer = signing.Signer(key="predictable-secret", algorithm="whatever")
msg = "'whatever' is not an algorithm accepted by the hashlib module."
with self.assertRaisesMessage(InvalidAlgorithm, msg):
signer.sign("hello")
def test_sign_unsign(self):
"sign/unsign should be reversible"
signer = signing.Signer(key="predictable-secret")
examples = [
"q;wjmbk;wkmb",
"3098247529087",
"3098247:529:087:",
"jkw osanteuh ,rcuh nthu aou oauh ,ud du",
"\u2019",
]
for example in examples:
signed = signer.sign(example)
self.assertIsInstance(signed, str)
self.assertNotEqual(example, signed)
self.assertEqual(example, signer.unsign(signed))
def test_sign_unsign_non_string(self):
signer = signing.Signer(key="predictable-secret")
values = [
123,
1.23,
True,
datetime.date.today(),
]
for value in values:
with self.subTest(value):
signed = signer.sign(value)
self.assertIsInstance(signed, str)
self.assertNotEqual(signed, value)
self.assertEqual(signer.unsign(signed), str(value))
def test_unsign_detects_tampering(self):
"unsign should raise an exception if the value has been tampered with"
signer = signing.Signer(key="predictable-secret")
value = "Another string"
signed_value = signer.sign(value)
transforms = (
lambda s: s.upper(),
lambda s: s + "a",
lambda s: "a" + s[1:],
lambda s: s.replace(":", ""),
)
self.assertEqual(value, signer.unsign(signed_value))
for transform in transforms:
with self.assertRaises(signing.BadSignature):
signer.unsign(transform(signed_value))
def test_sign_unsign_object(self):
signer = signing.Signer(key="predictable-secret")
tests = [
["a", "list"],
"a string \u2019",
{"a": "dictionary"},
]
for obj in tests:
with self.subTest(obj=obj):
signed_obj = signer.sign_object(obj)
self.assertNotEqual(obj, signed_obj)
self.assertEqual(obj, signer.unsign_object(signed_obj))
signed_obj = signer.sign_object(obj, compress=True)
self.assertNotEqual(obj, signed_obj)
self.assertEqual(obj, signer.unsign_object(signed_obj))
def test_dumps_loads(self):
"dumps and loads be reversible for any JSON serializable object"
objects = [
["a", "list"],
"a string \u2019",
{"a": "dictionary"},
]
for o in objects:
self.assertNotEqual(o, signing.dumps(o))
self.assertEqual(o, signing.loads(signing.dumps(o)))
self.assertNotEqual(o, signing.dumps(o, compress=True))
self.assertEqual(o, signing.loads(signing.dumps(o, compress=True)))
def test_decode_detects_tampering(self):
"loads should raise exception for tampered objects"
transforms = (
lambda s: s.upper(),
lambda s: s + "a",
lambda s: "a" + s[1:],
lambda s: s.replace(":", ""),
)
value = {
"foo": "bar",
"baz": 1,
}
encoded = signing.dumps(value)
self.assertEqual(value, signing.loads(encoded))
for transform in transforms:
with self.assertRaises(signing.BadSignature):
signing.loads(transform(encoded))
def test_works_with_non_ascii_keys(self):
binary_key = b"\xe7" # Set some binary (non-ASCII key)
s = signing.Signer(key=binary_key)
self.assertEqual(
"foo:EE4qGC5MEKyQG5msxYA0sBohAxLC0BJf8uRhemh0BGU",
s.sign("foo"),
)
def test_valid_sep(self):
separators = ["/", "*sep*", ","]
for sep in separators:
signer = signing.Signer(key="predictable-secret", sep=sep)
self.assertEqual(
"foo%sjZQoX_FtSO70jX9HLRGg2A_2s4kdDBxz1QoO_OpEQb0" % sep,
signer.sign("foo"),
)
def test_invalid_sep(self):
"""should warn on invalid separator"""
msg = (
"Unsafe Signer separator: %r (cannot be empty or consist of only A-z0-9-_=)"
)
separators = ["", "-", "abc"]
for sep in separators:
with self.assertRaisesMessage(ValueError, msg % sep):
signing.Signer(sep=sep)
def test_verify_with_non_default_key(self):
old_signer = signing.Signer(key="secret")
new_signer = signing.Signer(
key="newsecret", fallback_keys=["othersecret", "secret"]
)
signed = old_signer.sign("abc")
self.assertEqual(new_signer.unsign(signed), "abc")
def test_sign_unsign_multiple_keys(self):
"""The default key is a valid verification key."""
signer = signing.Signer(key="secret", fallback_keys=["oldsecret"])
signed = signer.sign("abc")
self.assertEqual(signer.unsign(signed), "abc")
@override_settings(
SECRET_KEY="secret",
SECRET_KEY_FALLBACKS=["oldsecret"],
)
def test_sign_unsign_ignore_secret_key_fallbacks(self):
old_signer = signing.Signer(key="oldsecret")
signed = old_signer.sign("abc")
signer = signing.Signer(fallback_keys=[])
with self.assertRaises(signing.BadSignature):
signer.unsign(signed)
@override_settings(
SECRET_KEY="secret",
SECRET_KEY_FALLBACKS=["oldsecret"],
)
def test_default_keys_verification(self):
old_signer = signing.Signer(key="oldsecret")
signed = old_signer.sign("abc")
signer = signing.Signer()
self.assertEqual(signer.unsign(signed), "abc")
class TestTimestampSigner(SimpleTestCase):
def test_timestamp_signer(self):
value = "hello"
with freeze_time(123456789):
signer = signing.TimestampSigner(key="predictable-key")
ts = signer.sign(value)
self.assertNotEqual(ts, signing.Signer(key="predictable-key").sign(value))
self.assertEqual(signer.unsign(ts), value)
with freeze_time(123456800):
self.assertEqual(signer.unsign(ts, max_age=12), value)
# max_age parameter can also accept a datetime.timedelta object
self.assertEqual(
signer.unsign(ts, max_age=datetime.timedelta(seconds=11)), value
)
with self.assertRaises(signing.SignatureExpired):
signer.unsign(ts, max_age=10)
class TestBase62(SimpleTestCase):
def test_base62(self):
tests = [-(10**10), 10**10, 1620378259, *range(-100, 100)]
for i in tests:
self.assertEqual(i, signing.b62_decode(signing.b62_encode(i)))
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/test_github_links.py | tests/sphinx/test_github_links.py | import pathlib
import sys
from django.test import SimpleTestCase
def last_n_parts(path, n):
return "/".join(path.parts[-n:])
# The import must happen at the end of setUpClass, so it can't be imported at
# the top of the file.
github_links = None
class GitHubLinkTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
# The file implementing the code under test is in the docs folder and
# is not part of the Django package. This means it cannot be imported
# through standard means. Include its parent in the pythonpath for the
# duration of the tests to allow the code to be imported.
cls.ext_path = str((pathlib.Path(__file__).parents[2] / "docs/_ext").resolve())
sys.path.insert(0, cls.ext_path)
cls.addClassCleanup(sys.path.remove, cls.ext_path)
cls.addClassCleanup(sys.modules.pop, "github_links", None)
# Linters/IDEs may not be able to detect this as a valid import.
import github_links as _github_links
global github_links
github_links = _github_links
def test_code_locator(self):
locator = github_links.CodeLocator.from_code(
"""
from a import b, c
from .d import e, f as g
def h():
pass
class I:
def j(self):
pass"""
)
self.assertEqual(locator.node_line_numbers, {"h": 5, "I": 8, "I.j": 9})
self.assertEqual(locator.import_locations, {"b": "a", "c": "a", "e": ".d"})
def test_module_name_to_file_path_package(self):
path = github_links.module_name_to_file_path("django")
self.assertEqual(last_n_parts(path, 2), "django/__init__.py")
def test_module_name_to_file_path_module(self):
path = github_links.module_name_to_file_path("django.shortcuts")
self.assertEqual(last_n_parts(path, 2), "django/shortcuts.py")
def test_get_path_and_line_class(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module", fullname="MyClass"
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/module.py"
)
self.assertEqual(line, 12)
def test_get_path_and_line_func(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module", fullname="my_function"
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/module.py"
)
self.assertEqual(line, 24)
def test_get_path_and_line_method(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module", fullname="MyClass.my_method"
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/module.py"
)
self.assertEqual(line, 16)
def test_get_path_and_line_cached_property(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module",
fullname="MyClass.my_cached_property",
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/module.py"
)
self.assertEqual(line, 20)
def test_get_path_and_line_forwarded_import(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module", fullname="MyOtherClass"
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/other_module.py"
)
self.assertEqual(line, 1)
def test_get_path_and_line_wildcard_import(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module", fullname="WildcardClass"
)
self.assertEqual(
last_n_parts(path, 5),
"tests/sphinx/testdata/package/wildcard_module.py",
)
self.assertEqual(line, 4)
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module",
fullname="WildcardMixin",
)
self.assertEqual(
last_n_parts(path, 5),
"tests/sphinx/testdata/package/wildcard_base.py",
)
self.assertEqual(line, 1)
def test_get_path_and_line_forwarded_import_module(self):
path, line = github_links.get_path_and_line(
module="tests.sphinx.testdata.package.module",
fullname="other_module.MyOtherClass",
)
self.assertEqual(
last_n_parts(path, 5), "tests/sphinx/testdata/package/other_module.py"
)
self.assertEqual(line, 1)
def test_get_branch_stable(self):
branch = github_links.get_branch(version="2.2", next_version="3.2")
self.assertEqual(branch, "stable/2.2.x")
def test_get_branch_latest(self):
branch = github_links.get_branch(version="3.2", next_version="3.2")
self.assertEqual(branch, "main")
def test_github_linkcode_resolve_unspecified_domain(self):
domain = "unspecified"
info = {}
self.assertIsNone(
github_links.github_linkcode_resolve(
domain, info, version="3.2", next_version="3.2"
)
)
def test_github_linkcode_resolve_unspecified_info(self):
domain = "py"
info = {"module": None, "fullname": None}
self.assertIsNone(
github_links.github_linkcode_resolve(
domain, info, version="3.2", next_version="3.2"
)
)
def test_github_linkcode_resolve_not_found(self):
info = {
"module": "foo.bar.baz.hopefully_non_existant_module",
"fullname": "MyClass",
}
self.assertIsNone(
github_links.github_linkcode_resolve(
"py", info, version="3.2", next_version="3.2"
)
)
def test_github_linkcode_resolve_link_to_object(self):
info = {
"module": "tests.sphinx.testdata.package.module",
"fullname": "MyClass",
}
self.assertEqual(
github_links.github_linkcode_resolve(
"py", info, version="3.2", next_version="3.2"
),
"https://github.com/django/django/blob/main/tests/sphinx/"
"testdata/package/module.py#L12",
)
def test_github_linkcode_resolve_link_to_class_older_version(self):
info = {
"module": "tests.sphinx.testdata.package.module",
"fullname": "MyClass",
}
self.assertEqual(
github_links.github_linkcode_resolve(
"py", info, version="2.2", next_version="3.2"
),
"https://github.com/django/django/blob/stable/2.2.x/tests/sphinx/"
"testdata/package/module.py#L12",
)
def test_import_error(self):
msg = "Could not import '.....test' in 'tests.sphinx.testdata.package'."
with self.assertRaisesMessage(ImportError, msg):
github_links.get_path_and_line(
module="tests.sphinx.testdata.package.import_error", fullname="Test"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/__init__.py | tests/sphinx/__init__.py | python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false | |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/import_error.py | tests/sphinx/testdata/package/import_error.py | from .....test import Test # noqa
class MyClass:
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/wildcard_base.py | tests/sphinx/testdata/package/wildcard_base.py | class WildcardMixin:
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/module.py | tests/sphinx/testdata/package/module.py | """
Example docstring
"""
from django.utils.functional import cached_property
from tests.sphinx.testdata.package.wildcard_module import * # noqa
from . import other_module # noqa
from .other_module import MyOtherClass # noqa
class MyClass(object):
def __init__(self):
pass
def my_method(self):
pass
@cached_property
def my_cached_property(self):
pass
def my_function(self):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/__init__.py | tests/sphinx/testdata/package/__init__.py | # This file should never get imported. If it is, then something failed already.
raise Exception
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/wildcard_module.py | tests/sphinx/testdata/package/wildcard_module.py | from .wildcard_base import WildcardMixin # noqa
class WildcardClass:
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/sphinx/testdata/package/other_module.py | tests/sphinx/testdata/package/other_module.py | class MyOtherClass:
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_utils/test_logentry.py | tests/admin_utils/test_logentry.py | import json
from datetime import datetime
from django.contrib.admin.models import ADDITION, CHANGE, DELETION, LogEntry
from django.contrib.admin.utils import quote
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.db.models.signals import post_save, pre_save
from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import translation
from django.utils.html import escape
from .models import Article, ArticleProxy, Car, Site
@override_settings(ROOT_URLCONF="admin_utils.urls")
class LogEntryTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.user = User.objects.create_superuser(
username="super", password="secret", email="super@example.com"
)
cls.site = Site.objects.create(domain="example.org")
cls.a1 = Article.objects.create(
site=cls.site,
title="Title",
created=datetime(2008, 3, 12, 11, 54),
)
cls.a2 = Article.objects.create(
site=cls.site,
title="Title 2",
created=datetime(2009, 3, 12, 11, 54),
)
cls.a3 = Article.objects.create(
site=cls.site,
title="Title 3",
created=datetime(2010, 3, 12, 11, 54),
)
LogEntry.objects.log_actions(
cls.user.pk,
[cls.a1],
CHANGE,
change_message="Changed something",
)
def setUp(self):
self.client.force_login(self.user)
self.signals = []
pre_save.connect(self.pre_save_listener, sender=LogEntry)
self.addCleanup(pre_save.disconnect, self.pre_save_listener, sender=LogEntry)
post_save.connect(self.post_save_listener, sender=LogEntry)
self.addCleanup(post_save.disconnect, self.post_save_listener, sender=LogEntry)
def pre_save_listener(self, instance, **kwargs):
self.signals.append(("pre_save", instance))
def post_save_listener(self, instance, created, **kwargs):
self.signals.append(("post_save", instance, created))
def test_logentry_save(self):
"""
LogEntry.action_time is a timestamp of the date when the entry was
created. It shouldn't be updated on a subsequent save().
"""
logentry = LogEntry.objects.get(content_type__model__iexact="article")
action_time = logentry.action_time
logentry.save()
self.assertEqual(logentry.action_time, action_time)
def test_logentry_change_message(self):
"""
LogEntry.change_message is stored as a dumped JSON structure to be able
to get the message dynamically translated at display time.
"""
post_data = {
"site": self.site.pk,
"title": "Changed",
"hist": "Some content",
"created_0": "2008-03-12",
"created_1": "11:54",
}
change_url = reverse(
"admin:admin_utils_article_change", args=[quote(self.a1.pk)]
)
response = self.client.post(change_url, post_data)
self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
logentry = LogEntry.objects.filter(
content_type__model__iexact="article"
).latest("id")
self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
with translation.override("fr"):
self.assertEqual(
logentry.get_change_message(), "Modification de Title et Historique."
)
add_url = reverse("admin:admin_utils_article_add")
post_data["title"] = "New"
response = self.client.post(add_url, post_data)
self.assertRedirects(response, reverse("admin:admin_utils_article_changelist"))
logentry = LogEntry.objects.filter(
content_type__model__iexact="article"
).latest("id")
self.assertEqual(logentry.get_change_message(), "Added.")
with translation.override("fr"):
self.assertEqual(logentry.get_change_message(), "Ajout.")
def test_logentry_change_message_not_json(self):
"""LogEntry.change_message was a string before Django 1.10."""
logentry = LogEntry(change_message="non-JSON string")
self.assertEqual(logentry.get_change_message(), logentry.change_message)
def test_logentry_change_message_localized_datetime_input(self):
"""
Localized date/time inputs shouldn't affect changed form data
detection.
"""
post_data = {
"site": self.site.pk,
"title": "Changed",
"hist": "Some content",
"created_0": "12/03/2008",
"created_1": "11:54",
}
with translation.override("fr"):
change_url = reverse(
"admin:admin_utils_article_change", args=[quote(self.a1.pk)]
)
response = self.client.post(change_url, post_data)
self.assertRedirects(
response, reverse("admin:admin_utils_article_changelist")
)
logentry = LogEntry.objects.filter(
content_type__model__iexact="article"
).latest("id")
self.assertEqual(logentry.get_change_message(), "Changed Title and History.")
def test_logentry_change_message_formsets(self):
"""
All messages for changed formsets are logged in a change message.
"""
a2 = Article.objects.create(
site=self.site,
title="Title second article",
created=datetime(2012, 3, 18, 11, 54),
)
post_data = {
"domain": "example.com", # domain changed
"admin_articles-TOTAL_FORMS": "5",
"admin_articles-INITIAL_FORMS": "2",
"admin_articles-MIN_NUM_FORMS": "0",
"admin_articles-MAX_NUM_FORMS": "1000",
# Changed title for 1st article
"admin_articles-0-id": str(self.a1.pk),
"admin_articles-0-site": str(self.site.pk),
"admin_articles-0-title": "Changed Title",
# Second article is deleted
"admin_articles-1-id": str(a2.pk),
"admin_articles-1-site": str(self.site.pk),
"admin_articles-1-title": "Title second article",
"admin_articles-1-DELETE": "on",
# A new article is added
"admin_articles-2-site": str(self.site.pk),
"admin_articles-2-title": "Added article",
}
change_url = reverse(
"admin:admin_utils_site_change", args=[quote(self.site.pk)]
)
response = self.client.post(change_url, post_data)
self.assertRedirects(response, reverse("admin:admin_utils_site_changelist"))
self.assertSequenceEqual(Article.objects.filter(pk=a2.pk), [])
logentry = LogEntry.objects.filter(content_type__model__iexact="site").latest(
"action_time"
)
self.assertEqual(
json.loads(logentry.change_message),
[
{"changed": {"fields": ["Domain"]}},
{"added": {"object": "Added article", "name": "article"}},
{
"changed": {
"fields": ["Title", "not_a_form_field"],
"object": "Changed Title",
"name": "article",
}
},
{"deleted": {"object": "Title second article", "name": "article"}},
],
)
self.assertEqual(
logentry.get_change_message(),
"Changed Domain. Added article “Added article”. "
"Changed Title and not_a_form_field for article “Changed Title”. "
"Deleted article “Title second article”.",
)
with translation.override("fr"):
self.assertEqual(
logentry.get_change_message(),
"Modification de Domain. Ajout de article « Added article ». "
"Modification de Title et not_a_form_field pour l'objet "
"article « Changed Title ». "
"Suppression de article « Title second article ».",
)
def test_logentry_get_edited_object(self):
"""
LogEntry.get_edited_object() returns the edited object of a LogEntry
object.
"""
logentry = LogEntry.objects.get(content_type__model__iexact="article")
edited_obj = logentry.get_edited_object()
self.assertEqual(logentry.object_id, str(edited_obj.pk))
def test_logentry_get_admin_url(self):
"""
LogEntry.get_admin_url returns a URL to edit the entry's object or
None for nonexistent (possibly deleted) models.
"""
logentry = LogEntry.objects.get(content_type__model__iexact="article")
expected_url = reverse(
"admin:admin_utils_article_change", args=(quote(self.a1.pk),)
)
self.assertEqual(logentry.get_admin_url(), expected_url)
self.assertIn("article/%d/change/" % self.a1.pk, logentry.get_admin_url())
logentry.content_type.model = "nonexistent"
self.assertIsNone(logentry.get_admin_url())
def test_logentry_unicode(self):
log_entry = LogEntry()
log_entry.action_flag = ADDITION
self.assertTrue(str(log_entry).startswith("Added "))
log_entry.action_flag = CHANGE
self.assertTrue(str(log_entry).startswith("Changed "))
log_entry.action_flag = DELETION
self.assertTrue(str(log_entry).startswith("Deleted "))
# Make sure custom action_flags works
log_entry.action_flag = 4
self.assertEqual(str(log_entry), "LogEntry Object")
def test_logentry_repr(self):
logentry = LogEntry.objects.first()
self.assertEqual(repr(logentry), str(logentry.action_time))
def test_log_actions(self):
queryset = Article.objects.all().order_by("-id")
msg = "Deleted Something"
content_type = ContentType.objects.get_for_model(self.a1)
self.assertEqual(len(queryset), 3)
with self.assertNumQueries(1):
result = LogEntry.objects.log_actions(
self.user.pk,
queryset,
DELETION,
change_message=msg,
)
self.assertEqual(len(result), len(queryset))
logs = (
LogEntry.objects.filter(action_flag=DELETION)
.order_by("id")
.values_list(
"user",
"content_type",
"object_id",
"object_repr",
"action_flag",
"change_message",
)
)
expected_log_values = [
(
self.user.pk,
content_type.id,
str(obj.pk),
str(obj),
DELETION,
msg,
)
for obj in queryset
]
result_logs = [
(
entry.user_id,
entry.content_type_id,
str(entry.object_id),
entry.object_repr,
entry.action_flag,
entry.change_message,
)
for entry in result
]
self.assertSequenceEqual(logs, result_logs)
self.assertSequenceEqual(logs, expected_log_values)
self.assertEqual(self.signals, [])
def test_log_actions_single_object_param(self):
queryset = Article.objects.filter(pk=self.a1.pk)
msg = "Deleted Something"
content_type = ContentType.objects.get_for_model(self.a1)
self.assertEqual(len(queryset), 1)
for single_object in (True, False):
self.signals = []
with self.subTest(single_object=single_object), self.assertNumQueries(1):
result = LogEntry.objects.log_actions(
self.user.pk,
queryset,
DELETION,
change_message=msg,
single_object=single_object,
)
if single_object:
self.assertIsInstance(result, LogEntry)
entry = result
else:
self.assertIsInstance(result, list)
self.assertEqual(len(result), 1)
entry = result[0]
self.assertEqual(entry.user_id, self.user.pk)
self.assertEqual(entry.content_type_id, content_type.id)
self.assertEqual(str(entry.object_id), str(self.a1.pk))
self.assertEqual(entry.object_repr, str(self.a1))
self.assertEqual(entry.action_flag, DELETION)
self.assertEqual(entry.change_message, msg)
expected_signals = [
("pre_save", entry),
("post_save", entry, True),
]
self.assertEqual(self.signals, expected_signals)
def test_recentactions_without_content_type(self):
"""
If a LogEntry is missing content_type it will not display it in span
tag under the hyperlink.
"""
response = self.client.get(reverse("admin:index"))
link = reverse("admin:admin_utils_article_change", args=(quote(self.a1.pk),))
should_contain = """<a href="%s">%s</a>""" % (
escape(link),
escape(str(self.a1)),
)
self.assertContains(response, should_contain)
should_contain = "Article"
self.assertContains(response, should_contain)
logentry = LogEntry.objects.get(content_type__model__iexact="article")
# If the log entry doesn't have a content type it should still be
# possible to view the Recent Actions part (#10275).
logentry.content_type = None
logentry.save()
should_contain = should_contain.encode()
counted_presence_before = response.content.count(should_contain)
response = self.client.get(reverse("admin:index"))
counted_presence_after = response.content.count(should_contain)
self.assertEqual(counted_presence_before - 1, counted_presence_after)
def test_proxy_model_content_type_is_used_for_log_entries(self):
"""
Log entries for proxy models should have the proxy model's contenttype
(#21084).
"""
proxy_content_type = ContentType.objects.get_for_model(
ArticleProxy, for_concrete_model=False
)
post_data = {
"site": self.site.pk,
"title": "Foo",
"hist": "Bar",
"created_0": "2015-12-25",
"created_1": "00:00",
}
changelist_url = reverse("admin:admin_utils_articleproxy_changelist")
expected_signals = []
self.assertEqual(self.signals, expected_signals)
# add
proxy_add_url = reverse("admin:admin_utils_articleproxy_add")
response = self.client.post(proxy_add_url, post_data)
self.assertRedirects(response, changelist_url)
proxy_addition_log = LogEntry.objects.latest("id")
self.assertEqual(proxy_addition_log.action_flag, ADDITION)
self.assertEqual(proxy_addition_log.content_type, proxy_content_type)
expected_signals.extend(
[("pre_save", proxy_addition_log), ("post_save", proxy_addition_log, True)]
)
self.assertEqual(self.signals, expected_signals)
# change
article_id = proxy_addition_log.object_id
proxy_change_url = reverse(
"admin:admin_utils_articleproxy_change", args=(article_id,)
)
post_data["title"] = "New"
response = self.client.post(proxy_change_url, post_data)
self.assertRedirects(response, changelist_url)
proxy_change_log = LogEntry.objects.latest("id")
self.assertEqual(proxy_change_log.action_flag, CHANGE)
self.assertEqual(proxy_change_log.content_type, proxy_content_type)
expected_signals.extend(
[("pre_save", proxy_change_log), ("post_save", proxy_change_log, True)]
)
self.assertEqual(self.signals, expected_signals)
# delete
proxy_delete_url = reverse(
"admin:admin_utils_articleproxy_delete", args=(article_id,)
)
response = self.client.post(proxy_delete_url, {"post": "yes"})
self.assertRedirects(response, changelist_url)
proxy_delete_log = LogEntry.objects.latest("id")
self.assertEqual(proxy_delete_log.action_flag, DELETION)
self.assertEqual(proxy_delete_log.content_type, proxy_content_type)
expected_signals.extend(
[("pre_save", proxy_delete_log), ("post_save", proxy_delete_log, True)]
)
self.assertEqual(self.signals, expected_signals)
def test_action_flag_choices(self):
tests = ((1, "Addition"), (2, "Change"), (3, "Deletion"))
for action_flag, display_name in tests:
with self.subTest(action_flag=action_flag):
log = LogEntry(action_flag=action_flag)
self.assertEqual(log.get_action_flag_display(), display_name)
def test_hook_get_log_entries(self):
LogEntry.objects.log_actions(
self.user.pk,
[self.a1],
CHANGE,
change_message="Article changed message",
)
c1 = Car.objects.create()
LogEntry.objects.log_actions(
self.user.pk,
[c1],
ADDITION,
change_message="Car created message",
)
exp_str_article = escape(str(self.a1))
exp_str_car = escape(str(c1))
response = self.client.get(reverse("admin:index"))
self.assertContains(response, exp_str_article)
self.assertContains(response, exp_str_car)
# site "custom_admin" only renders log entries of registered models
response = self.client.get(reverse("custom_admin:index"))
self.assertContains(response, exp_str_article)
self.assertNotContains(response, exp_str_car)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_utils/admin.py | tests/admin_utils/admin.py | from django import forms
from django.contrib import admin
from .models import Article, ArticleProxy, Site
class ArticleAdminForm(forms.ModelForm):
nolabel_form_field = forms.BooleanField(required=False)
class Meta:
model = Article
fields = ["title"]
@property
def changed_data(self):
data = super().changed_data
if data:
# Add arbitrary name to changed_data to test
# change message construction.
return data + ["not_a_form_field"]
return data
class ArticleInline(admin.TabularInline):
model = Article
fields = ["title"]
form = ArticleAdminForm
class SiteAdmin(admin.ModelAdmin):
inlines = [ArticleInline]
site = admin.AdminSite(name="admin")
site.register(Article)
site.register(ArticleProxy)
site.register(Site, SiteAdmin)
class CustomAdminSite(admin.AdminSite):
def get_log_entries(self, request):
from django.contrib.contenttypes.models import ContentType
log_entries = super().get_log_entries(request)
return log_entries.filter(
content_type__in=ContentType.objects.get_for_models(
*self._registry.keys()
).values()
)
custom_site = CustomAdminSite(name="custom_admin")
custom_site.register(Article)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_utils/models.py | tests/admin_utils/models.py | from django.contrib import admin
from django.db import models
from django.utils.translation import gettext_lazy as _
class Site(models.Model):
domain = models.CharField(max_length=100)
def __str__(self):
return self.domain
class Article(models.Model):
"""
A simple Article model for testing
"""
site = models.ForeignKey(Site, models.CASCADE, related_name="admin_articles")
title = models.CharField(max_length=100)
hist = models.CharField(
max_length=100,
verbose_name=_("History"),
help_text=_("History help text"),
)
created = models.DateTimeField(null=True)
def __str__(self):
return self.title
def test_from_model(self):
return "nothing"
@admin.display(description="not What you Expect")
def test_from_model_with_override(self):
return "nothing"
class ArticleProxy(Article):
class Meta:
proxy = True
class Cascade(models.Model):
num = models.PositiveSmallIntegerField()
parent = models.ForeignKey("self", models.CASCADE, null=True)
def __str__(self):
return str(self.num)
class DBCascade(models.Model):
num = models.PositiveSmallIntegerField()
parent = models.ForeignKey("self", models.DB_CASCADE, null=True)
def __str__(self):
return str(self.num)
class Meta:
required_db_features = {"supports_on_delete_db_cascade"}
class Event(models.Model):
date = models.DateTimeField(auto_now_add=True)
class Location(models.Model):
event = models.OneToOneField(Event, models.CASCADE, verbose_name="awesome event")
class Guest(models.Model):
event = models.OneToOneField(Event, models.CASCADE)
name = models.CharField(max_length=255)
class Meta:
verbose_name = "awesome guest"
class EventGuide(models.Model):
event = models.ForeignKey(Event, models.DO_NOTHING)
class Vehicle(models.Model):
pass
class VehicleMixin(Vehicle):
vehicle = models.OneToOneField(
Vehicle,
models.CASCADE,
parent_link=True,
related_name="vehicle_%(app_label)s_%(class)s",
)
class Meta:
abstract = True
class Car(VehicleMixin):
pass
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_utils/__init__.py | tests/admin_utils/__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_utils/tests.py | tests/admin_utils/tests.py | from datetime import datetime
from decimal import Decimal
from django import forms
from django.conf import settings
from django.contrib import admin
from django.contrib.admin import helpers
from django.contrib.admin.utils import (
NestedObjects,
build_q_object_from_lookup_parameters,
display_for_field,
display_for_value,
flatten,
flatten_fieldsets,
help_text_for_field,
label_for_field,
lookup_field,
quote,
)
from django.contrib.auth.models import User
from django.contrib.auth.templatetags.auth import render_password_as_hash
from django.core.validators import EMPTY_VALUES
from django.db import DEFAULT_DB_ALIAS, models
from django.test import SimpleTestCase, TestCase, override_settings, skipUnlessDBFeature
from django.test.utils import isolate_apps
from django.utils.formats import localize
from django.utils.safestring import mark_safe
from .models import (
Article,
Car,
Cascade,
DBCascade,
Event,
EventGuide,
Location,
Site,
Vehicle,
)
class NestedObjectsTests(TestCase):
"""
Tests for ``NestedObject`` utility collection.
"""
cascade_model = Cascade
@classmethod
def setUpTestData(cls):
cls.n = NestedObjects(using=DEFAULT_DB_ALIAS)
cls.objs = [cls.cascade_model.objects.create(num=i) for i in range(5)]
def _check(self, target):
self.assertEqual(self.n.nested(lambda obj: obj.num), target)
def _connect(self, i, j):
self.objs[i].parent = self.objs[j]
self.objs[i].save()
def _collect(self, *indices):
self.n.collect([self.objs[i] for i in indices])
def test_unrelated_roots(self):
self._connect(2, 1)
self._collect(0)
self._collect(1)
self._check([0, 1, [2]])
def test_siblings(self):
self._connect(1, 0)
self._connect(2, 0)
self._collect(0)
self._check([0, [1, 2]])
def test_non_added_parent(self):
self._connect(0, 1)
self._collect(0)
self._check([0])
def test_cyclic(self):
self._connect(0, 2)
self._connect(1, 0)
self._connect(2, 1)
self._collect(0)
self._check([0, [1, [2]]])
def test_queries(self):
self._connect(1, 0)
self._connect(2, 0)
# 1 query to fetch all children of 0 (1 and 2)
# 1 query to fetch all children of 1 and 2 (none)
# Should not require additional queries to populate the nested graph.
self.assertNumQueries(2, self._collect, 0)
def test_on_delete_do_nothing(self):
"""
The nested collector doesn't query for DO_NOTHING objects.
"""
n = NestedObjects(using=DEFAULT_DB_ALIAS)
objs = [Event.objects.create()]
EventGuide.objects.create(event=objs[0])
with self.assertNumQueries(2):
# One for Location, one for Guest, and no query for EventGuide
n.collect(objs)
def test_relation_on_abstract(self):
"""
NestedObjects.collect() doesn't trip (AttributeError) on the special
notation for relations on abstract models (related_name that contains
%(app_label)s and/or %(class)s) (#21846).
"""
n = NestedObjects(using=DEFAULT_DB_ALIAS)
Car.objects.create()
n.collect([Vehicle.objects.first()])
@skipUnlessDBFeature("supports_on_delete_db_cascade")
class DBNestedObjectsTests(NestedObjectsTests):
"""
Exercise NestedObjectsTests but with a model that makes use of DB_CASCADE
instead of CASCADE to ensure proper collection of objects takes place.
"""
cascade_model = DBCascade
class UtilsTests(SimpleTestCase):
empty_value = "-empty-"
def test_values_from_lookup_field(self):
"""
Regression test for #12654: lookup_field
"""
SITE_NAME = "example.com"
TITLE_TEXT = "Some title"
CREATED_DATE = datetime.min
ADMIN_METHOD = "admin method"
SIMPLE_FUNCTION = "function"
INSTANCE_ATTRIBUTE = "attr"
class MockModelAdmin:
def get_admin_value(self, obj):
return ADMIN_METHOD
def simple_function(obj):
return SIMPLE_FUNCTION
site_obj = Site(domain=SITE_NAME)
article = Article(
site=site_obj,
title=TITLE_TEXT,
created=CREATED_DATE,
)
article.non_field = INSTANCE_ATTRIBUTE
verifications = (
("site", SITE_NAME),
("created", localize(CREATED_DATE)),
("title", TITLE_TEXT),
("get_admin_value", ADMIN_METHOD),
(simple_function, SIMPLE_FUNCTION),
("test_from_model", article.test_from_model()),
("non_field", INSTANCE_ATTRIBUTE),
("site__domain", SITE_NAME),
)
mock_admin = MockModelAdmin()
for name, value in verifications:
field, attr, resolved_value = lookup_field(name, article, mock_admin)
if field is not None:
resolved_value = display_for_field(
resolved_value, field, self.empty_value
)
self.assertEqual(value, resolved_value)
def test_empty_value_display_for_field(self):
tests = [
models.CharField(),
models.DateField(),
models.DecimalField(),
models.FloatField(),
models.URLField(),
models.JSONField(),
models.TimeField(),
]
for model_field in tests:
for value in model_field.empty_values:
with self.subTest(model_field=model_field, empty_value=value):
display_value = display_for_field(
value, model_field, self.empty_value
)
self.assertEqual(display_value, self.empty_value)
def test_empty_value_display_choices(self):
model_field = models.CharField(choices=((None, "test_none"),))
display_value = display_for_field(None, model_field, self.empty_value)
self.assertEqual(display_value, "test_none")
def test_empty_value_display_booleanfield(self):
model_field = models.BooleanField(null=True)
display_value = display_for_field(None, model_field, self.empty_value)
expected = (
f'<img src="{settings.STATIC_URL}admin/img/icon-unknown.svg" alt="None" />'
)
self.assertHTMLEqual(display_value, expected)
def test_json_display_for_field(self):
tests = [
({"a": {"b": "c"}}, '{"a": {"b": "c"}}'),
(["a", "b"], '["a", "b"]'),
("a", '"a"'),
({"a": "你好 世界"}, '{"a": "你好 世界"}'),
({("a", "b"): "c"}, "{('a', 'b'): 'c'}"), # Invalid JSON.
]
for value, display_value in tests:
with self.subTest(value=value):
self.assertEqual(
display_for_field(value, models.JSONField(), self.empty_value),
display_value,
)
def test_url_display_for_field(self):
model_field = models.URLField()
display_value = display_for_field(
"http://example.com", model_field, self.empty_value
)
expected = '<a href="http://example.com">http://example.com</a>'
self.assertHTMLEqual(display_value, expected)
def test_number_formats_display_for_field(self):
display_value = display_for_field(
12345.6789, models.FloatField(), self.empty_value
)
self.assertEqual(display_value, "12345.6789")
display_value = display_for_field(
Decimal("12345.6789"), models.DecimalField(), self.empty_value
)
self.assertEqual(display_value, "12345.6789")
display_value = display_for_field(
12345, models.IntegerField(), self.empty_value
)
self.assertEqual(display_value, "12345")
@override_settings(USE_THOUSAND_SEPARATOR=True)
def test_number_formats_with_thousand_separator_display_for_field(self):
display_value = display_for_field(
12345.6789, models.FloatField(), self.empty_value
)
self.assertEqual(display_value, "12,345.6789")
display_value = display_for_field(
Decimal("12345.6789"), models.DecimalField(), self.empty_value
)
self.assertEqual(display_value, "12,345.6789")
display_value = display_for_field(
12345, models.IntegerField(), self.empty_value
)
self.assertEqual(display_value, "12,345")
@isolate_apps("admin_utils")
def test_display_for_field_password_name_not_user_model(self):
class PasswordModel(models.Model):
password = models.CharField(max_length=200)
password_field = PasswordModel._meta.get_field("password")
display_value = display_for_field("test", password_field, self.empty_value)
self.assertEqual(display_value, "test")
def test_password_display_for_field_user_model(self):
password_field = User._meta.get_field("password")
for password in [
"invalid",
"md5$zjIiKM8EiyfXEGiexlQRw4$a59a82cf344546e7bc09cb5f2246370a",
"!b7pk7RNudAXGTNLK6fW5YnBCLVE6UUmeoJJYQHaO",
]:
with self.subTest(password=password):
display_value = display_for_field(
password, password_field, self.empty_value
)
self.assertEqual(display_value, render_password_as_hash(password))
def test_list_display_for_value(self):
display_value = display_for_value([1, 2, 3], self.empty_value)
self.assertEqual(display_value, "1, 2, 3")
display_value = display_for_value(
[1, 2, "buckle", "my", "shoe"], self.empty_value
)
self.assertEqual(display_value, "1, 2, buckle, my, shoe")
@override_settings(USE_THOUSAND_SEPARATOR=True)
def test_list_display_for_value_boolean(self):
self.assertEqual(
display_for_value(True, "", boolean=True),
'<img src="/static/admin/img/icon-yes.svg" alt="True">',
)
self.assertEqual(
display_for_value(False, "", boolean=True),
'<img src="/static/admin/img/icon-no.svg" alt="False">',
)
self.assertEqual(display_for_value(True, ""), "True")
self.assertEqual(display_for_value(False, ""), "False")
def test_list_display_for_value_empty(self):
for value in EMPTY_VALUES:
with self.subTest(empty_value=value):
display_value = display_for_value(value, self.empty_value)
self.assertEqual(display_value, self.empty_value)
def test_label_for_field(self):
"""
Tests for label_for_field
"""
self.assertEqual(label_for_field("title", Article), "title")
self.assertEqual(label_for_field("hist", Article), "History")
self.assertEqual(
label_for_field("hist", Article, return_attr=True), ("History", None)
)
self.assertEqual(label_for_field("__str__", Article), "article")
with self.assertRaisesMessage(
AttributeError, "Unable to lookup 'unknown' on Article"
):
label_for_field("unknown", Article)
def test_callable(obj):
return "nothing"
self.assertEqual(label_for_field(test_callable, Article), "Test callable")
self.assertEqual(
label_for_field(test_callable, Article, return_attr=True),
("Test callable", test_callable),
)
self.assertEqual(label_for_field("test_from_model", Article), "Test from model")
self.assertEqual(
label_for_field("test_from_model", Article, return_attr=True),
("Test from model", Article.test_from_model),
)
self.assertEqual(
label_for_field("test_from_model_with_override", Article),
"not What you Expect",
)
self.assertEqual(label_for_field(lambda x: "nothing", Article), "--")
self.assertEqual(label_for_field("site_id", Article), "Site id")
# The correct name and attr are returned when `__` is in the field
# name.
self.assertEqual(label_for_field("site__domain", Article), "Site domain")
self.assertEqual(
label_for_field("site__domain", Article, return_attr=True),
("Site domain", Site._meta.get_field("domain")),
)
def test_label_for_field_failed_lookup(self):
msg = "Unable to lookup 'site__unknown' on Article"
with self.assertRaisesMessage(AttributeError, msg):
label_for_field("site__unknown", Article)
class MockModelAdmin:
@admin.display(description="not Really the Model")
def test_from_model(self, obj):
return "nothing"
self.assertEqual(
label_for_field("test_from_model", Article, model_admin=MockModelAdmin),
"not Really the Model",
)
self.assertEqual(
label_for_field(
"test_from_model", Article, model_admin=MockModelAdmin, return_attr=True
),
("not Really the Model", MockModelAdmin.test_from_model),
)
def test_label_for_field_form_argument(self):
class ArticleForm(forms.ModelForm):
extra_form_field = forms.BooleanField()
class Meta:
fields = "__all__"
model = Article
self.assertEqual(
label_for_field("extra_form_field", Article, form=ArticleForm()),
"Extra form field",
)
msg = "Unable to lookup 'nonexistent' on Article or ArticleForm"
with self.assertRaisesMessage(AttributeError, msg):
label_for_field("nonexistent", Article, form=ArticleForm())
def test_label_for_property(self):
class MockModelAdmin:
@property
@admin.display(description="property short description")
def test_from_property(self):
return "this if from property"
self.assertEqual(
label_for_field("test_from_property", Article, model_admin=MockModelAdmin),
"property short description",
)
def test_help_text_for_field(self):
tests = [
("article", ""),
("unknown", ""),
("hist", "History help text"),
]
for name, help_text in tests:
with self.subTest(name=name):
self.assertEqual(help_text_for_field(name, Article), help_text)
def test_related_name(self):
"""
Regression test for #13963
"""
self.assertEqual(
label_for_field("location", Event, return_attr=True),
("location", None),
)
self.assertEqual(
label_for_field("event", Location, return_attr=True),
("awesome event", None),
)
self.assertEqual(
label_for_field("guest", Event, return_attr=True),
("awesome guest", None),
)
def test_safestring_in_field_label(self):
# safestring should not be escaped
class MyForm(forms.Form):
text = forms.CharField(label=mark_safe("<i>text</i>"))
cb = forms.BooleanField(label=mark_safe("<i>cb</i>"))
form = MyForm()
self.assertHTMLEqual(
helpers.AdminField(form, "text", is_first=False).label_tag(),
'<label for="id_text" class="required inline"><i>text</i>:</label>',
)
self.assertHTMLEqual(
helpers.AdminField(form, "cb", is_first=False).label_tag(),
'<label for="id_cb" class="vCheckboxLabel required inline">'
"<i>cb</i></label>",
)
# normal strings needs to be escaped
class MyForm(forms.Form):
text = forms.CharField(label="&text")
cb = forms.BooleanField(label="&cb")
form = MyForm()
self.assertHTMLEqual(
helpers.AdminField(form, "text", is_first=False).label_tag(),
'<label for="id_text" class="required inline">&text:</label>',
)
self.assertHTMLEqual(
helpers.AdminField(form, "cb", is_first=False).label_tag(),
'<label for="id_cb" class="vCheckboxLabel required inline">&cb</label>',
)
def test_flatten(self):
flat_all = ["url", "title", "content", "sites"]
inputs = (
((), []),
(("url", "title", ("content", "sites")), flat_all),
(("url", "title", "content", "sites"), flat_all),
((("url", "title"), ("content", "sites")), flat_all),
)
for orig, expected in inputs:
self.assertEqual(flatten(orig), expected)
def test_flatten_fieldsets(self):
"""
Regression test for #18051
"""
fieldsets = ((None, {"fields": ("url", "title", ("content", "sites"))}),)
self.assertEqual(
flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
)
fieldsets = ((None, {"fields": ("url", "title", ["content", "sites"])}),)
self.assertEqual(
flatten_fieldsets(fieldsets), ["url", "title", "content", "sites"]
)
def test_quote(self):
self.assertEqual(quote("something\nor\nother"), "something_0Aor_0Aother")
def test_build_q_object_from_lookup_parameters(self):
parameters = {
"title__in": [["Article 1", "Article 2"]],
"hist__iexact": ["history"],
"site__pk": [1, 2],
}
q_obj = build_q_object_from_lookup_parameters(parameters)
self.assertEqual(
q_obj,
models.Q(title__in=["Article 1", "Article 2"])
& models.Q(hist__iexact="history")
& (models.Q(site__pk=1) | models.Q(site__pk=2)),
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/admin_utils/urls.py | tests/admin_utils/urls.py | from django.urls import path
from .admin import custom_site, site
urlpatterns = [
path("test_admin/admin/", site.urls),
path("test_admin/custom_admin/", custom_site.urls),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/no_slash_urls.py | tests/flatpages_tests/no_slash_urls.py | from django.urls import include, path
urlpatterns = [
path("flatpage", include("django.contrib.flatpages.urls")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_forms.py | tests/flatpages_tests/test_forms.py | from django.conf import settings
from django.contrib.flatpages.forms import FlatpageForm
from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site
from django.test import TestCase, modify_settings, override_settings
from django.utils import translation
@modify_settings(INSTALLED_APPS={"append": ["django.contrib.flatpages"]})
@override_settings(SITE_ID=1)
class FlatpageAdminFormTests(TestCase):
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain="example.com", name="example.com")
cls.site1.save()
def setUp(self):
# Site fields cache needs to be cleared after flatpages is added to
# INSTALLED_APPS
Site._meta._expire_cache()
self.form_data = {
"title": "A test page",
"content": "This is a test",
"sites": [settings.SITE_ID],
}
def test_flatpage_admin_form_url_validation(self):
"The flatpage admin form correctly validates urls"
self.assertTrue(
FlatpageForm(data=dict(url="/new_flatpage/", **self.form_data)).is_valid()
)
self.assertTrue(
FlatpageForm(
data=dict(url="/some.special~chars/", **self.form_data)
).is_valid()
)
self.assertTrue(
FlatpageForm(
data=dict(url="/some.very_special~chars-here/", **self.form_data)
).is_valid()
)
self.assertFalse(
FlatpageForm(data=dict(url="/a space/", **self.form_data)).is_valid()
)
self.assertFalse(
FlatpageForm(data=dict(url="/a % char/", **self.form_data)).is_valid()
)
self.assertFalse(
FlatpageForm(data=dict(url="/a ! char/", **self.form_data)).is_valid()
)
self.assertFalse(
FlatpageForm(data=dict(url="/a & char/", **self.form_data)).is_valid()
)
self.assertFalse(
FlatpageForm(data=dict(url="/a ? char/", **self.form_data)).is_valid()
)
def test_flatpage_requires_leading_slash(self):
form = FlatpageForm(data=dict(url="no_leading_slash/", **self.form_data))
with translation.override("en"):
self.assertFalse(form.is_valid())
self.assertEqual(form.errors["url"], ["URL is missing a leading slash."])
@override_settings(
APPEND_SLASH=True, MIDDLEWARE=["django.middleware.common.CommonMiddleware"]
)
def test_flatpage_requires_trailing_slash_with_append_slash(self):
form = FlatpageForm(data=dict(url="/no_trailing_slash", **self.form_data))
with translation.override("en"):
self.assertEqual(
form.fields["url"].help_text,
"Example: “/about/contact/”. Make sure to have leading and "
"trailing slashes.",
)
self.assertFalse(form.is_valid())
self.assertEqual(form.errors["url"], ["URL is missing a trailing slash."])
@override_settings(
APPEND_SLASH=False, MIDDLEWARE=["django.middleware.common.CommonMiddleware"]
)
def test_flatpage_doesnt_requires_trailing_slash_without_append_slash(self):
form = FlatpageForm(data=dict(url="/no_trailing_slash", **self.form_data))
self.assertTrue(form.is_valid())
with translation.override("en"):
self.assertEqual(
form.fields["url"].help_text,
"Example: “/about/contact”. Make sure to have a leading slash.",
)
def test_flatpage_admin_form_url_uniqueness_validation(self):
"""
The flatpage admin form correctly enforces url uniqueness among
flatpages of the same site.
"""
data = dict(url="/myflatpage1/", **self.form_data)
FlatpageForm(data=data).save()
f = FlatpageForm(data=data)
with translation.override("en"):
self.assertFalse(f.is_valid())
self.assertEqual(
f.errors,
{
"__all__": [
"Flatpage with url /myflatpage1/ already exists for site "
"example.com"
]
},
)
def test_flatpage_admin_form_edit(self):
"""
Existing flatpages can be edited in the admin form without triggering
the url-uniqueness validation.
"""
existing = FlatPage.objects.create(
url="/myflatpage1/", title="Some page", content="The content"
)
existing.sites.add(settings.SITE_ID)
data = dict(url="/myflatpage1/", **self.form_data)
f = FlatpageForm(data=data, instance=existing)
self.assertTrue(f.is_valid(), f.errors)
updated = f.save()
self.assertEqual(updated.title, "A test page")
def test_flatpage_nosites(self):
data = dict(url="/myflatpage1/", **self.form_data)
data.update({"sites": ""})
f = FlatpageForm(data=data)
self.assertFalse(f.is_valid())
self.assertEqual(
f.errors, {"sites": [translation.gettext("This field is required.")]}
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_views.py | tests/flatpages_tests/test_views.py | from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site
from django.test import TestCase, modify_settings, override_settings
from .settings import FLATPAGES_TEMPLATES
class TestDataMixin:
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain="example.com", name="example.com")
cls.site1.save()
cls.fp1 = FlatPage.objects.create(
url="/flatpage/",
title="A Flatpage",
content="Isn't it flat!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp2 = FlatPage.objects.create(
url="/location/flatpage/",
title="A Nested Flatpage",
content="Isn't it flat and deep!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp3 = FlatPage.objects.create(
url="/sekrit/",
title="Sekrit Flatpage",
content="Isn't it sekrit!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp4 = FlatPage.objects.create(
url="/location/sekrit/",
title="Sekrit Nested Flatpage",
content="Isn't it sekrit and deep!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp1.sites.add(cls.site1)
cls.fp2.sites.add(cls.site1)
cls.fp3.sites.add(cls.site1)
cls.fp4.sites.add(cls.site1)
@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
@override_settings(
LOGIN_URL="/accounts/login/",
MIDDLEWARE=[
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
# no 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'
],
ROOT_URLCONF="flatpages_tests.urls",
TEMPLATES=FLATPAGES_TEMPLATES,
SITE_ID=1,
)
class FlatpageViewTests(TestDataMixin, TestCase):
def test_view_flatpage(self):
"A flatpage can be served through a view"
response = self.client.get("/flatpage_root/flatpage/")
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self):
"""A nonexistent flatpage raises 404 when served through a view."""
response = self.client.get("/flatpage_root/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication"
response = self.client.get("/flatpage_root/sekrit/")
self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
user = User.objects.create_user("testuser", "test@example.com", "s3krit")
self.client.force_login(user)
response = self.client.get("/flatpage_root/sekrit/")
self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self):
"A fallback flatpage won't be served if the middleware is disabled"
response = self.client.get("/flatpage/")
self.assertEqual(response.status_code, 404)
def test_fallback_non_existent_flatpage(self):
"""
A nonexistent flatpage won't be served if the fallback middleware is
disabled.
"""
response = self.client.get("/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_view_flatpage_special_chars(self):
"A flatpage with special chars in the URL can be served through a view"
fp = FlatPage.objects.create(
url="/some.very_special~chars-here/",
title="A very special page",
content="Isn't it special!",
enable_comments=False,
registration_required=False,
)
fp.sites.add(settings.SITE_ID)
response = self.client.get("/flatpage_root/some.very_special~chars-here/")
self.assertContains(response, "<p>Isn't it special!</p>")
@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
@override_settings(
APPEND_SLASH=True,
LOGIN_URL="/accounts/login/",
MIDDLEWARE=[
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
# no 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'
],
ROOT_URLCONF="flatpages_tests.urls",
TEMPLATES=FLATPAGES_TEMPLATES,
SITE_ID=1,
)
class FlatpageViewAppendSlashTests(TestDataMixin, TestCase):
def test_redirect_view_flatpage(self):
"A flatpage can be served through a view and should add a slash"
response = self.client.get("/flatpage_root/flatpage")
self.assertRedirects(response, "/flatpage_root/flatpage/", status_code=301)
def test_redirect_view_non_existent_flatpage(self):
"""
A nonexistent flatpage raises 404 when served through a view and
should not add a slash.
"""
response = self.client.get("/flatpage_root/no_such_flatpage")
self.assertEqual(response.status_code, 404)
def test_redirect_fallback_flatpage(self):
"""
A fallback flatpage won't be served if the middleware is disabled and
should not add a slash.
"""
response = self.client.get("/flatpage")
self.assertEqual(response.status_code, 404)
def test_redirect_fallback_non_existent_flatpage(self):
"""
A nonexistent flatpage won't be served if the fallback middleware is
disabled and should not add a slash.
"""
response = self.client.get("/no_such_flatpage")
self.assertEqual(response.status_code, 404)
def test_redirect_view_flatpage_special_chars(self):
"""
A flatpage with special chars in the URL can be served through a view
and should add a slash.
"""
fp = FlatPage.objects.create(
url="/some.very_special~chars-here/",
title="A very special page",
content="Isn't it special!",
enable_comments=False,
registration_required=False,
)
fp.sites.add(settings.SITE_ID)
response = self.client.get("/flatpage_root/some.very_special~chars-here")
self.assertRedirects(
response, "/flatpage_root/some.very_special~chars-here/", status_code=301
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_templatetags.py | tests/flatpages_tests/test_templatetags.py | from django.contrib.auth.models import AnonymousUser, User
from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site
from django.template import Context, Template, TemplateSyntaxError
from django.test import TestCase
class FlatpageTemplateTagTests(TestCase):
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain="example.com", name="example.com")
cls.site1.save()
cls.fp1 = FlatPage.objects.create(
url="/flatpage/",
title="A Flatpage",
content="Isn't it flat!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp2 = FlatPage.objects.create(
url="/location/flatpage/",
title="A Nested Flatpage",
content="Isn't it flat and deep!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp3 = FlatPage.objects.create(
url="/sekrit/",
title="Sekrit Flatpage",
content="Isn't it sekrit!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp4 = FlatPage.objects.create(
url="/location/sekrit/",
title="Sekrit Nested Flatpage",
content="Isn't it sekrit and deep!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp1.sites.add(cls.site1)
cls.fp2.sites.add(cls.site1)
cls.fp3.sites.add(cls.site1)
cls.fp4.sites.add(cls.site1)
def test_get_flatpages_tag(self):
"""
The flatpage template tag retrieves unregistered prefixed flatpages by
default
"""
out = Template(
"{% load flatpages %}"
"{% get_flatpages as flatpages %}"
"{% for page in flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context())
self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
def test_get_flatpages_tag_for_anon_user(self):
"""
The flatpage template tag retrieves unregistered flatpages for an
anonymous user.
"""
out = Template(
"{% load flatpages %}"
"{% get_flatpages for anonuser as flatpages %}"
"{% for page in flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context({"anonuser": AnonymousUser()}))
self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
def test_get_flatpages_tag_for_user(self):
"""
The flatpage template tag retrieves all flatpages for an authenticated
user
"""
me = User.objects.create_user("testuser", "test@example.com", "s3krit")
out = Template(
"{% load flatpages %}"
"{% get_flatpages for me as flatpages %}"
"{% for page in flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context({"me": me}))
self.assertEqual(
out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,"
)
def test_get_flatpages_with_prefix(self):
"""
The flatpage template tag retrieves unregistered prefixed flatpages by
default
"""
out = Template(
"{% load flatpages %}"
"{% get_flatpages '/location/' as location_flatpages %}"
"{% for page in location_flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context())
self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_anon_user(self):
"""
The flatpage template tag retrieves unregistered prefixed flatpages for
an anonymous user.
"""
out = Template(
"{% load flatpages %}"
"{% get_flatpages '/location/' for anonuser as location_flatpages %}"
"{% for page in location_flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context({"anonuser": AnonymousUser()}))
self.assertEqual(out, "A Nested Flatpage,")
def test_get_flatpages_with_prefix_for_user(self):
"""
The flatpage template tag retrieve prefixed flatpages for an
authenticated user.
"""
me = User.objects.create_user("testuser", "test@example.com", "s3krit")
out = Template(
"{% load flatpages %}"
"{% get_flatpages '/location/' for me as location_flatpages %}"
"{% for page in location_flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context({"me": me}))
self.assertEqual(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
def test_get_flatpages_with_variable_prefix(self):
"The prefix for the flatpage template tag can be a template variable"
out = Template(
"{% load flatpages %}"
"{% get_flatpages location_prefix as location_flatpages %}"
"{% for page in location_flatpages %}"
"{{ page.title }},"
"{% endfor %}"
).render(Context({"location_prefix": "/location/"}))
self.assertEqual(out, "A Nested Flatpage,")
def test_parsing_errors(self):
"There are various ways that the flatpages template tag won't parse"
def render(t):
return Template(t).render(Context())
msg = (
"get_flatpages expects a syntax of get_flatpages "
"['url_starts_with'] [for user] as context_name"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render("{% load flatpages %}{% get_flatpages %}")
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render("{% load flatpages %}{% get_flatpages as %}")
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render("{% load flatpages %}{% get_flatpages cheesecake flatpages %}")
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render("{% load flatpages %}{% get_flatpages as flatpages asdf %}")
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render(
"{% load flatpages %}{% get_flatpages cheesecake user as flatpages %}"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render("{% load flatpages %}{% get_flatpages for user as flatpages asdf %}")
with self.assertRaisesMessage(TemplateSyntaxError, msg):
render(
"{% load flatpages %}"
"{% get_flatpages prefix for user as flatpages asdf %}"
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_csrf.py | tests/flatpages_tests/test_csrf.py | from django.contrib.auth.models import User
from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site
from django.test import Client, TestCase, modify_settings, override_settings
from .settings import FLATPAGES_TEMPLATES
@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
@override_settings(
LOGIN_URL="/accounts/login/",
MIDDLEWARE=[
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
],
ROOT_URLCONF="flatpages_tests.urls",
CSRF_FAILURE_VIEW="django.views.csrf.csrf_failure",
TEMPLATES=FLATPAGES_TEMPLATES,
SITE_ID=1,
)
class FlatpageCSRFTests(TestCase):
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain="example.com", name="example.com")
cls.site1.save()
cls.fp1 = FlatPage.objects.create(
url="/flatpage/",
title="A Flatpage",
content="Isn't it flat!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp2 = FlatPage.objects.create(
url="/location/flatpage/",
title="A Nested Flatpage",
content="Isn't it flat and deep!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp3 = FlatPage.objects.create(
url="/sekrit/",
title="Sekrit Flatpage",
content="Isn't it sekrit!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp4 = FlatPage.objects.create(
url="/location/sekrit/",
title="Sekrit Nested Flatpage",
content="Isn't it sekrit and deep!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp1.sites.add(cls.site1)
cls.fp2.sites.add(cls.site1)
cls.fp3.sites.add(cls.site1)
cls.fp4.sites.add(cls.site1)
def setUp(self):
self.client = Client(enforce_csrf_checks=True)
def test_view_flatpage(self):
"""
A flatpage can be served through a view, even when the middleware is in
use
"""
response = self.client.get("/flatpage_root/flatpage/")
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self):
"""
A nonexistent flatpage raises 404 when served through a view, even when
the middleware is in use.
"""
response = self.client.get("/flatpage_root/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication"
response = self.client.get("/flatpage_root/sekrit/")
self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
user = User.objects.create_user("testuser", "test@example.com", "s3krit")
self.client.force_login(user)
response = self.client.get("/flatpage_root/sekrit/")
self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self):
"A flatpage can be served by the fallback middleware"
response = self.client.get("/flatpage/")
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_fallback_non_existent_flatpage(self):
"""
A nonexistent flatpage raises a 404 when served by the fallback
middleware.
"""
response = self.client.get("/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_post_view_flatpage(self):
"""
POSTing to a flatpage served through a view will raise a CSRF error if
no token is provided.
"""
response = self.client.post("/flatpage_root/flatpage/")
self.assertEqual(response.status_code, 403)
def test_post_fallback_flatpage(self):
"""
POSTing to a flatpage served by the middleware will raise a CSRF error
if no token is provided.
"""
response = self.client.post("/flatpage/")
self.assertEqual(response.status_code, 403)
def test_post_unknown_page(self):
"POSTing to an unknown page isn't caught as a 403 CSRF error"
response = self.client.post("/no_such_page/")
self.assertEqual(response.status_code, 404)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_models.py | tests/flatpages_tests/test_models.py | from django.contrib.flatpages.models import FlatPage
from django.test import SimpleTestCase, override_settings
from django.test.utils import override_script_prefix
class FlatpageModelTests(SimpleTestCase):
def setUp(self):
self.page = FlatPage(title="Café!", url="/café/")
def test_get_absolute_url_urlencodes(self):
self.assertEqual(self.page.get_absolute_url(), "/caf%C3%A9/")
@override_script_prefix("/prefix/")
def test_get_absolute_url_honors_script_prefix(self):
self.assertEqual(self.page.get_absolute_url(), "/prefix/caf%C3%A9/")
def test_str(self):
self.assertEqual(str(self.page), "/café/ -- Café!")
@override_settings(ROOT_URLCONF="flatpages_tests.urls")
def test_get_absolute_url_include(self):
self.assertEqual(self.page.get_absolute_url(), "/flatpage_root/caf%C3%A9/")
@override_settings(ROOT_URLCONF="flatpages_tests.no_slash_urls")
def test_get_absolute_url_include_no_slash(self):
self.assertEqual(self.page.get_absolute_url(), "/flatpagecaf%C3%A9/")
@override_settings(ROOT_URLCONF="flatpages_tests.absolute_urls")
def test_get_absolute_url_with_hardcoded_url(self):
fp = FlatPage(title="Test", url="/hardcoded/")
self.assertEqual(fp.get_absolute_url(), "/flatpage/")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_middleware.py | tests/flatpages_tests/test_middleware.py | from django.conf import settings
from django.contrib.auth.models import User
from django.contrib.flatpages.models import FlatPage
from django.contrib.sites.models import Site
from django.test import TestCase, modify_settings, override_settings
from .settings import FLATPAGES_TEMPLATES
class TestDataMixin:
@classmethod
def setUpTestData(cls):
# don't use the manager because we want to ensure the site exists
# with pk=1, regardless of whether or not it already exists.
cls.site1 = Site(pk=1, domain="example.com", name="example.com")
cls.site1.save()
cls.fp1 = FlatPage.objects.create(
url="/flatpage/",
title="A Flatpage",
content="Isn't it flat!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp2 = FlatPage.objects.create(
url="/location/flatpage/",
title="A Nested Flatpage",
content="Isn't it flat and deep!",
enable_comments=False,
template_name="",
registration_required=False,
)
cls.fp3 = FlatPage.objects.create(
url="/sekrit/",
title="Sekrit Flatpage",
content="Isn't it sekrit!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp4 = FlatPage.objects.create(
url="/location/sekrit/",
title="Sekrit Nested Flatpage",
content="Isn't it sekrit and deep!",
enable_comments=False,
template_name="",
registration_required=True,
)
cls.fp1.sites.add(cls.site1)
cls.fp2.sites.add(cls.site1)
cls.fp3.sites.add(cls.site1)
cls.fp4.sites.add(cls.site1)
@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
@override_settings(
LOGIN_URL="/accounts/login/",
MIDDLEWARE=[
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
],
ROOT_URLCONF="flatpages_tests.urls",
TEMPLATES=FLATPAGES_TEMPLATES,
SITE_ID=1,
)
class FlatpageMiddlewareTests(TestDataMixin, TestCase):
def test_view_flatpage(self):
"""
A flatpage can be served through a view, even when the middleware is in
use
"""
response = self.client.get("/flatpage_root/flatpage/")
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_view_non_existent_flatpage(self):
"""
A nonexistent flatpage raises 404 when served through a view, even when
the middleware is in use.
"""
response = self.client.get("/flatpage_root/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_view_authenticated_flatpage(self):
"A flatpage served through a view can require authentication"
response = self.client.get("/flatpage_root/sekrit/")
self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")
user = User.objects.create_user("testuser", "test@example.com", "s3krit")
self.client.force_login(user)
response = self.client.get("/flatpage_root/sekrit/")
self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage(self):
"A flatpage can be served by the fallback middleware"
response = self.client.get("/flatpage/")
self.assertContains(response, "<p>Isn't it flat!</p>")
def test_fallback_non_existent_flatpage(self):
"""
A nonexistent flatpage raises a 404 when served by the fallback
middleware.
"""
response = self.client.get("/no_such_flatpage/")
self.assertEqual(response.status_code, 404)
def test_fallback_authenticated_flatpage(self):
"A flatpage served by the middleware can require authentication"
response = self.client.get("/sekrit/")
self.assertRedirects(response, "/accounts/login/?next=/sekrit/")
user = User.objects.create_user("testuser", "test@example.com", "s3krit")
self.client.force_login(user)
response = self.client.get("/sekrit/")
self.assertContains(response, "<p>Isn't it sekrit!</p>")
def test_fallback_flatpage_special_chars(self):
"""
A flatpage with special chars in the URL can be served by the fallback
middleware.
"""
fp = FlatPage.objects.create(
url="/some.very_special~chars-here/",
title="A very special page",
content="Isn't it special!",
enable_comments=False,
registration_required=False,
)
fp.sites.add(settings.SITE_ID)
response = self.client.get("/some.very_special~chars-here/")
self.assertContains(response, "<p>Isn't it special!</p>")
@modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})
@override_settings(
APPEND_SLASH=True,
LOGIN_URL="/accounts/login/",
MIDDLEWARE=[
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",
],
ROOT_URLCONF="flatpages_tests.urls",
TEMPLATES=FLATPAGES_TEMPLATES,
SITE_ID=1,
)
class FlatpageMiddlewareAppendSlashTests(TestDataMixin, TestCase):
def test_redirect_view_flatpage(self):
"A flatpage can be served through a view and should add a slash"
response = self.client.get("/flatpage_root/flatpage")
self.assertRedirects(response, "/flatpage_root/flatpage/", status_code=301)
def test_redirect_view_non_existent_flatpage(self):
"""
A nonexistent flatpage raises 404 when served through a view and
should not add a slash.
"""
response = self.client.get("/flatpage_root/no_such_flatpage")
self.assertEqual(response.status_code, 404)
def test_redirect_fallback_flatpage(self):
"""
A flatpage can be served by the fallback middleware and should add a
slash
"""
response = self.client.get("/flatpage")
self.assertRedirects(response, "/flatpage/", status_code=301)
def test_redirect_fallback_non_existent_flatpage(self):
"""
A nonexistent flatpage raises a 404 when served by the fallback
middleware and should not add a slash.
"""
response = self.client.get("/no_such_flatpage")
self.assertEqual(response.status_code, 404)
def test_redirect_fallback_flatpage_special_chars(self):
"""
A flatpage with special chars in the URL can be served by the fallback
middleware and should add a slash.
"""
fp = FlatPage.objects.create(
url="/some.very_special~chars-here/",
title="A very special page",
content="Isn't it special!",
enable_comments=False,
registration_required=False,
)
fp.sites.add(settings.SITE_ID)
response = self.client.get("/some.very_special~chars-here")
self.assertRedirects(
response, "/some.very_special~chars-here/", status_code=301
)
def test_redirect_fallback_flatpage_root(self):
"""
A flatpage at / should not cause a redirect loop when APPEND_SLASH is
set
"""
fp = FlatPage.objects.create(
url="/",
title="Root",
content="Root",
enable_comments=False,
registration_required=False,
)
fp.sites.add(settings.SITE_ID)
response = self.client.get("/")
self.assertContains(response, "<p>Root</p>")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/settings.py | tests/flatpages_tests/settings.py | import os
FLATPAGES_TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [os.path.join(os.path.dirname(__file__), "templates")],
"OPTIONS": {
"context_processors": ("django.contrib.auth.context_processors.auth",),
},
}
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/test_sitemaps.py | tests/flatpages_tests/test_sitemaps.py | from django.apps import apps
from django.contrib.sites.models import Site
from django.test import TestCase
from django.test.utils import modify_settings, override_settings
@override_settings(
ROOT_URLCONF="flatpages_tests.urls",
SITE_ID=1,
)
@modify_settings(
INSTALLED_APPS={
"append": ["django.contrib.sitemaps", "django.contrib.flatpages"],
},
)
class FlatpagesSitemapTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
# This cleanup is necessary because contrib.sites cache
# makes tests interfere with each other, see #11505
Site.objects.clear_cache()
@classmethod
def setUpTestData(cls):
Site = apps.get_model("sites.Site")
current_site = Site.objects.get_current()
current_site.flatpage_set.create(url="/foo/", title="foo")
current_site.flatpage_set.create(
url="/private-foo/", title="private foo", registration_required=True
)
def test_flatpage_sitemap(self):
response = self.client.get("/flatpages/sitemap.xml")
self.assertIn(
b"<url><loc>http://example.com/flatpage_root/foo/</loc></url>",
response.getvalue(),
)
self.assertNotIn(
b"<url><loc>http://example.com/flatpage_root/private-foo/</loc></url>",
response.getvalue(),
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/__init__.py | tests/flatpages_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/flatpages_tests/absolute_urls.py | tests/flatpages_tests/absolute_urls.py | from django.contrib.flatpages import views
from django.urls import path
urlpatterns = [
path("flatpage/", views.flatpage, {"url": "/hardcoded/"}),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/flatpages_tests/urls.py | tests/flatpages_tests/urls.py | from django.contrib.flatpages.sitemaps import FlatPageSitemap
from django.contrib.sitemaps import views
from django.urls import include, path
urlpatterns = [
path(
"flatpages/sitemap.xml",
views.sitemap,
{"sitemaps": {"flatpages": FlatPageSitemap}},
name="django.contrib.sitemaps.views.sitemap",
),
path("flatpage_root/", include("django.contrib.flatpages.urls")),
path("accounts/", include("django.contrib.auth.urls")),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_library.py | tests/template_tests/test_library.py | import functools
import unittest
from django.template import Library
from django.template.base import Node
from django.test import SimpleTestCase
from django.utils.version import PY314
class FilterRegistrationTests(SimpleTestCase):
def setUp(self):
self.library = Library()
def test_filter(self):
@self.library.filter
def func():
return ""
self.assertEqual(self.library.filters["func"], func)
def test_filter_parens(self):
@self.library.filter()
def func():
return ""
self.assertEqual(self.library.filters["func"], func)
def test_filter_name_arg(self):
@self.library.filter("name")
def func():
return ""
self.assertEqual(self.library.filters["name"], func)
def test_filter_name_kwarg(self):
@self.library.filter(name="name")
def func():
return ""
self.assertEqual(self.library.filters["name"], func)
def test_filter_call(self):
def func():
return ""
self.library.filter("name", func)
self.assertEqual(self.library.filters["name"], func)
def test_filter_invalid(self):
msg = "Unsupported arguments to Library.filter: (None, '')"
with self.assertRaisesMessage(ValueError, msg):
self.library.filter(None, "")
class InclusionTagRegistrationTests(SimpleTestCase):
def setUp(self):
self.library = Library()
def test_inclusion_tag(self):
@self.library.inclusion_tag("template.html")
def func():
return ""
self.assertIn("func", self.library.tags)
def test_inclusion_tag_name(self):
@self.library.inclusion_tag("template.html", name="name")
def func():
return ""
self.assertIn("name", self.library.tags)
def test_inclusion_tag_wrapped(self):
@self.library.inclusion_tag("template.html")
@functools.lru_cache(maxsize=32)
def func():
return ""
func_wrapped = self.library.tags["func"].__wrapped__
self.assertIs(func_wrapped, func)
self.assertTrue(hasattr(func_wrapped, "cache_info"))
@unittest.skipUnless(PY314, "Deferred annotations are Python 3.14+ only")
def test_inclusion_tag_deferred_annotation(self):
@self.library.inclusion_tag("template.html")
def func(arg: SomeType): # NOQA: F821
return ""
self.assertIn("func", self.library.tags)
class SimpleTagRegistrationTests(SimpleTestCase):
def setUp(self):
self.library = Library()
def test_simple_tag(self):
@self.library.simple_tag
def func():
return ""
self.assertIn("func", self.library.tags)
def test_simple_tag_parens(self):
@self.library.simple_tag()
def func():
return ""
self.assertIn("func", self.library.tags)
def test_simple_tag_name_kwarg(self):
@self.library.simple_tag(name="name")
def func():
return ""
self.assertIn("name", self.library.tags)
@unittest.skipUnless(PY314, "Deferred annotations are Python 3.14+ only")
def test_tag_deferred_annotation(self):
@self.library.simple_tag
def func(parser, token: SomeType): # NOQA: F821
return Node()
self.assertIn("func", self.library.tags)
def test_simple_tag_invalid(self):
msg = "Invalid arguments provided to simple_tag"
with self.assertRaisesMessage(ValueError, msg):
self.library.simple_tag("invalid")
def test_simple_tag_wrapped(self):
@self.library.simple_tag
@functools.lru_cache(maxsize=32)
def func():
return ""
func_wrapped = self.library.tags["func"].__wrapped__
self.assertIs(func_wrapped, func)
self.assertTrue(hasattr(func_wrapped, "cache_info"))
class SimpleBlockTagRegistrationTests(SimpleTestCase):
def setUp(self):
self.library = Library()
def test_simple_block_tag(self):
@self.library.simple_block_tag
def func(content):
return content
self.assertIn("func", self.library.tags)
def test_simple_block_tag_parens(self):
@self.library.simple_block_tag()
def func(content):
return content
self.assertIn("func", self.library.tags)
def test_simple_block_tag_name_kwarg(self):
@self.library.simple_block_tag(name="name")
def func(content):
return content
self.assertIn("name", self.library.tags)
@unittest.skipUnless(PY314, "Deferred annotations are Python 3.14+ only")
def test_simple_block_tag_deferred_annotation(self):
@self.library.simple_block_tag
def func(content: SomeType): # NOQA: F821
return content
self.assertIn("func", self.library.tags)
def test_simple_block_tag_invalid(self):
msg = "Invalid arguments provided to simple_block_tag"
with self.assertRaisesMessage(ValueError, msg):
self.library.simple_block_tag("invalid")
def test_simple_tag_wrapped(self):
@self.library.simple_block_tag
@functools.lru_cache(maxsize=32)
def func(content):
return content
func_wrapped = self.library.tags["func"].__wrapped__
self.assertIs(func_wrapped, func)
self.assertTrue(hasattr(func_wrapped, "cache_info"))
class TagRegistrationTests(SimpleTestCase):
def setUp(self):
self.library = Library()
def test_tag(self):
@self.library.tag
def func(parser, token):
return Node()
self.assertEqual(self.library.tags["func"], func)
def test_tag_parens(self):
@self.library.tag()
def func(parser, token):
return Node()
self.assertEqual(self.library.tags["func"], func)
def test_tag_name_arg(self):
@self.library.tag("name")
def func(parser, token):
return Node()
self.assertEqual(self.library.tags["name"], func)
def test_tag_name_kwarg(self):
@self.library.tag(name="name")
def func(parser, token):
return Node()
self.assertEqual(self.library.tags["name"], func)
def test_tag_call(self):
def func(parser, token):
return Node()
self.library.tag("name", func)
self.assertEqual(self.library.tags["name"], func)
def test_tag_invalid(self):
msg = "Unsupported arguments to Library.tag: (None, '')"
with self.assertRaisesMessage(ValueError, msg):
self.library.tag(None, "")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_engine.py | tests/template_tests/test_engine.py | import os
from django.core.exceptions import ImproperlyConfigured
from django.template import Context
from django.template.engine import Engine
from django.test import SimpleTestCase, override_settings
from .utils import ROOT, TEMPLATE_DIR
OTHER_DIR = os.path.join(ROOT, "other_templates")
class EngineTest(SimpleTestCase):
def test_repr_empty(self):
engine = Engine()
self.assertEqual(
repr(engine),
"<Engine: app_dirs=False debug=False loaders=[("
"'django.template.loaders.cached.Loader', "
"['django.template.loaders.filesystem.Loader'])] "
"string_if_invalid='' file_charset='utf-8' builtins=["
"'django.template.defaulttags', 'django.template.defaultfilters', "
"'django.template.loader_tags'] autoescape=True>",
)
def test_repr(self):
engine = Engine(
dirs=[TEMPLATE_DIR],
context_processors=["django.template.context_processors.debug"],
debug=True,
loaders=["django.template.loaders.filesystem.Loader"],
string_if_invalid="x",
file_charset="utf-16",
libraries={"custom": "template_tests.templatetags.custom"},
autoescape=False,
)
self.assertEqual(
repr(engine),
f"<Engine: dirs=[{TEMPLATE_DIR!r}] app_dirs=False "
"context_processors=['django.template.context_processors.debug'] "
"debug=True loaders=['django.template.loaders.filesystem.Loader'] "
"string_if_invalid='x' file_charset='utf-16' "
"libraries={'custom': 'template_tests.templatetags.custom'} "
"builtins=['django.template.defaulttags', "
"'django.template.defaultfilters', 'django.template.loader_tags'] "
"autoescape=False>",
)
class RenderToStringTest(SimpleTestCase):
def setUp(self):
self.engine = Engine(dirs=[TEMPLATE_DIR])
def test_basic_context(self):
self.assertEqual(
self.engine.render_to_string("test_context.html", {"obj": "test"}),
"obj:test\n",
)
def test_autoescape_off(self):
engine = Engine(dirs=[TEMPLATE_DIR], autoescape=False)
self.assertEqual(
engine.render_to_string("test_context.html", {"obj": "<script>"}),
"obj:<script>\n",
)
class GetDefaultTests(SimpleTestCase):
@override_settings(TEMPLATES=[])
def test_no_engines_configured(self):
msg = "No DjangoTemplates backend is configured."
with self.assertRaisesMessage(ImproperlyConfigured, msg):
Engine.get_default()
@override_settings(
TEMPLATES=[
{
"NAME": "default",
"BACKEND": "django.template.backends.django.DjangoTemplates",
"OPTIONS": {"file_charset": "abc"},
}
]
)
def test_single_engine_configured(self):
self.assertEqual(Engine.get_default().file_charset, "abc")
@override_settings(
TEMPLATES=[
{
"NAME": "default",
"BACKEND": "django.template.backends.django.DjangoTemplates",
"OPTIONS": {"file_charset": "abc"},
},
{
"NAME": "other",
"BACKEND": "django.template.backends.django.DjangoTemplates",
"OPTIONS": {"file_charset": "def"},
},
]
)
def test_multiple_engines_configured(self):
self.assertEqual(Engine.get_default().file_charset, "abc")
class LoaderTests(SimpleTestCase):
def test_origin(self):
engine = Engine(dirs=[TEMPLATE_DIR], debug=True)
template = engine.get_template("index.html")
self.assertEqual(template.origin.template_name, "index.html")
def test_loader_priority(self):
"""
#21460 -- The order of template loader works.
"""
loaders = [
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
]
engine = Engine(dirs=[OTHER_DIR, TEMPLATE_DIR], loaders=loaders)
template = engine.get_template("priority/foo.html")
self.assertEqual(template.render(Context()), "priority\n")
def test_cached_loader_priority(self):
"""
The order of template loader works. Refs #21460.
"""
loaders = [
(
"django.template.loaders.cached.Loader",
[
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
],
),
]
engine = Engine(dirs=[OTHER_DIR, TEMPLATE_DIR], loaders=loaders)
template = engine.get_template("priority/foo.html")
self.assertEqual(template.render(Context()), "priority\n")
template = engine.get_template("priority/foo.html")
self.assertEqual(template.render(Context()), "priority\n")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_logging.py | tests/template_tests/test_logging.py | import logging
from django.template import Engine, Variable, VariableDoesNotExist
from django.test import SimpleTestCase
class VariableResolveLoggingTests(SimpleTestCase):
loglevel = logging.DEBUG
def test_log_on_variable_does_not_exist_silent(self):
class TestObject:
class SilentDoesNotExist(Exception):
silent_variable_failure = True
@property
def template_name(self):
return "template_name"
@property
def template(self):
return Engine().from_string("")
@property
def article(self):
raise TestObject.SilentDoesNotExist("Attribute does not exist.")
def __iter__(self):
return (attr for attr in dir(TestObject) if attr[:2] != "__")
def __getitem__(self, item):
return self.__dict__[item]
with self.assertLogs("django.template", self.loglevel) as cm:
Variable("article").resolve(TestObject())
self.assertEqual(len(cm.records), 1)
log_record = cm.records[0]
self.assertEqual(
log_record.getMessage(),
"Exception while resolving variable 'article' in template 'template_name'.",
)
self.assertIsNotNone(log_record.exc_info)
raised_exception = log_record.exc_info[1]
self.assertEqual(str(raised_exception), "Attribute does not exist.")
def test_log_on_variable_does_not_exist_not_silent(self):
with self.assertLogs("django.template", self.loglevel) as cm:
with self.assertRaises(VariableDoesNotExist):
Variable("article.author").resolve({"article": {"section": "News"}})
self.assertEqual(len(cm.records), 1)
log_record = cm.records[0]
self.assertEqual(
log_record.getMessage(),
"Exception while resolving variable 'author' in template 'unknown'.",
)
self.assertIsNotNone(log_record.exc_info)
raised_exception = log_record.exc_info[1]
self.assertEqual(
str(raised_exception),
"Failed lookup for key [author] in {'section': 'News'}",
)
def test_no_log_when_variable_exists(self):
with self.assertNoLogs("django.template", self.loglevel):
Variable("article.section").resolve({"article": {"section": "News"}})
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/views.py | tests/template_tests/views.py | # Fake views for testing url reverse lookup
from django.http import HttpResponse
from django.template.response import TemplateResponse
def index(request):
pass
def client(request, id):
pass
def client_action(request, id, action):
pass
def client2(request, tag):
pass
def template_response_view(request):
return TemplateResponse(request, "response.html", {})
def snark(request):
return HttpResponse("Found them!")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_parser.py | tests/template_tests/test_parser.py | """
Testing some internals of the template processing.
These are *not* examples to be copied in user code.
"""
import unittest
from django.template import Library, TemplateSyntaxError
from django.template.base import (
FilterExpression,
Lexer,
Parser,
Token,
TokenType,
Variable,
VariableDoesNotExist,
)
from django.template.defaultfilters import register as filter_library
from django.test import SimpleTestCase
from django.utils.version import PY314
class ParserTests(SimpleTestCase):
def test_token_smart_split(self):
"""
#7027 -- _() syntax should work with spaces
"""
token = Token(
TokenType.BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")'
)
split = token.split_contents()
self.assertEqual(
split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")']
)
def test_repr(self):
token = Token(TokenType.BLOCK, "some text")
self.assertEqual(repr(token), '<Block token: "some text...">')
parser = Parser([token], builtins=[filter_library])
self.assertEqual(
repr(parser),
'<Parser tokens=[<Block token: "some text...">]>',
)
filter_expression = FilterExpression("news|upper", parser)
self.assertEqual(repr(filter_expression), "<FilterExpression 'news|upper'>")
lexer = Lexer("{% for i in 1 %}{{ a }}\n{% endfor %}")
self.assertEqual(
repr(lexer),
'<Lexer template_string="{% for i in 1 %}{{ a...", verbatim=False>',
)
def test_filter_parsing(self):
c = {"article": {"section": "News"}}
p = Parser("", builtins=[filter_library])
def fe_test(s, val):
self.assertEqual(FilterExpression(s, p).resolve(c), val)
fe_test("article.section", "News")
fe_test("article.section|upper", "NEWS")
fe_test('"News"', "News")
fe_test("'News'", "News")
fe_test(r'"Some \"Good\" News"', 'Some "Good" News')
fe_test(r'"Some \"Good\" News"', 'Some "Good" News')
fe_test(r"'Some \'Bad\' News'", "Some 'Bad' News")
fe = FilterExpression(r'"Some \"Good\" News"', p)
self.assertEqual(fe.filters, [])
self.assertEqual(fe.var, 'Some "Good" News')
# Filtered variables should reject access of attributes beginning with
# underscores.
msg = (
"Variables and attributes may not begin with underscores: 'article._hidden'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
FilterExpression("article._hidden|upper", p)
def test_cannot_parse_characters(self):
p = Parser("", builtins=[filter_library])
for filter_expression, characters in [
('<>|default:"Default"|upper', '|<>||default:"Default"|upper'),
("test|<>|upper", "test||<>||upper"),
]:
with self.subTest(filter_expression=filter_expression):
with self.assertRaisesMessage(
TemplateSyntaxError,
f"Could not parse some characters: {characters}",
):
FilterExpression(filter_expression, p)
def test_cannot_find_variable(self):
p = Parser("", builtins=[filter_library])
with self.assertRaisesMessage(
TemplateSyntaxError,
'Could not find variable at start of |default:"Default"',
):
FilterExpression('|default:"Default"', p)
def test_variable_parsing(self):
c = {"article": {"section": "News"}}
self.assertEqual(Variable("article.section").resolve(c), "News")
self.assertEqual(Variable('"News"').resolve(c), "News")
self.assertEqual(Variable("'News'").resolve(c), "News")
# Translated strings are handled correctly.
self.assertEqual(Variable("_(article.section)").resolve(c), "News")
self.assertEqual(Variable('_("Good News")').resolve(c), "Good News")
self.assertEqual(Variable("_('Better News')").resolve(c), "Better News")
# Escaped quotes work correctly as well.
self.assertEqual(
Variable(r'"Some \"Good\" News"').resolve(c), 'Some "Good" News'
)
self.assertEqual(
Variable(r"'Some \'Better\' News'").resolve(c), "Some 'Better' News"
)
# Variables should reject access of attributes and variables beginning
# with underscores.
for name in ["article._hidden", "_article"]:
msg = f"Variables and attributes may not begin with underscores: '{name}'"
with self.assertRaisesMessage(TemplateSyntaxError, msg):
Variable(name)
# Variables should raise on non string type
with self.assertRaisesMessage(
TypeError, "Variable must be a string or number, got <class 'dict'>"
):
Variable({})
# Variables should raise when invalid characters in name.
for c in ["+", "-"]:
with self.subTest(invalid_character=c):
variable_name = f"variable{c}name"
with self.assertRaisesMessage(
TemplateSyntaxError,
f"Invalid character ('{c}') in variable name: '{variable_name}'",
):
Variable(variable_name)
def test_filter_args_count(self):
parser = Parser("")
register = Library()
@register.filter
def no_arguments(value):
pass
@register.filter
def one_argument(value, arg):
pass
@register.filter
def one_opt_argument(value, arg=False):
pass
@register.filter
def two_arguments(value, arg, arg2):
pass
@register.filter
def two_one_opt_arg(value, arg, arg2=False):
pass
parser.add_library(register)
for expr in (
'1|no_arguments:"1"',
"1|two_arguments",
'1|two_arguments:"1"',
"1|two_one_opt_arg",
):
with self.assertRaises(TemplateSyntaxError):
FilterExpression(expr, parser)
for expr in (
# Correct number of arguments
"1|no_arguments",
'1|one_argument:"1"',
# One optional
"1|one_opt_argument",
'1|one_opt_argument:"1"',
# Not supplying all
'1|two_one_opt_arg:"1"',
):
FilterExpression(expr, parser)
def test_filter_numeric_argument_parsing(self):
p = Parser("", builtins=[filter_library])
# Values that resolve to a numeric literal.
cases = {
"5": 5,
"-5": -5,
"5.2": 5.2,
".4": 0.4,
"5.2e3": 5200.0, # 5.2 × 10³ = 5200.0.
"5.2E3": 5200.0, # Case-insensitive.
"5.2e-3": 0.0052, # Negative exponent.
"-1.5E4": -15000.0,
"+3.0e2": 300.0,
".5e2": 50.0, # 0.5 × 10² = 50.0
}
for num, expected in cases.items():
with self.subTest(num=num):
self.assertEqual(FilterExpression(num, p).resolve({}), expected)
self.assertEqual(
FilterExpression(f"0|default:{num}", p).resolve({}), expected
)
# Values that are interpreted as names of variables that do not exist.
invalid_numbers = [
"abc123",
"123abc",
"foo",
"error",
"1e",
"e400",
"1e.2",
"1e2.",
"1e2.0",
"1e2a",
"1e2e3",
]
for num in invalid_numbers:
with self.subTest(num=num):
self.assertIsNone(
FilterExpression(num, p).resolve({}, ignore_failures=True)
)
with self.assertRaises(VariableDoesNotExist):
FilterExpression(f"0|default:{num}", p).resolve({})
# Values that are interpreted as an invalid variable name.
invalid_numbers_and_var_names = [
"1e-",
"1e-a",
"1+1",
"1-1",
]
for num in invalid_numbers_and_var_names:
with self.subTest(num=num):
with self.assertRaises(TemplateSyntaxError):
FilterExpression(num, p).resolve({})
with self.assertRaises(TemplateSyntaxError):
FilterExpression(f"0|default:{num}", p).resolve({})
@unittest.skipUnless(PY314, "Deferred annotations are Python 3.14+ only")
def test_filter_deferred_annotation(self):
register = Library()
@register.filter("example")
def example_filter(value: str, arg: SomeType): # NOQA: F821
return f"{value}_{arg}"
result = FilterExpression.args_check(
"example", example_filter, ["extra_example"]
)
self.assertIs(result, True)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_origin.py | tests/template_tests/test_origin.py | import os
from unittest import TestCase
from django.template import Engine
from .utils import TEMPLATE_DIR
class OriginTestCase(TestCase):
def setUp(self):
self.engine = Engine(dirs=[TEMPLATE_DIR])
def test_origin_compares_equal(self):
a = self.engine.get_template("index.html")
b = self.engine.get_template("index.html")
self.assertEqual(a.origin, b.origin)
# Use assertIs() to test __eq__/__ne__.
self.assertIs(a.origin == b.origin, True)
self.assertIs(a.origin != b.origin, False)
def test_origin_compares_not_equal(self):
a = self.engine.get_template("first/test.html")
b = self.engine.get_template("second/test.html")
self.assertNotEqual(a.origin, b.origin)
# Use assertIs() to test __eq__/__ne__.
self.assertIs(a.origin == b.origin, False)
self.assertIs(a.origin != b.origin, True)
def test_repr(self):
a = self.engine.get_template("index.html")
name = os.path.join(TEMPLATE_DIR, "index.html")
self.assertEqual(repr(a.origin), "<Origin name=%r>" % name)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_base.py | tests/template_tests/test_base.py | from django.template import Context, Template, Variable, VariableDoesNotExist
from django.template.base import DebugLexer, Lexer, TokenType
from django.test import SimpleTestCase
from django.utils.translation import gettext_lazy
class LexerTestMixin:
template_string = (
"text\n"
"{% if test %}{{ varvalue }}{% endif %}"
"{#comment {{not a var}} {%not a block%} #}"
"end text"
)
expected_token_tuples = [
# (token_type, contents, lineno, position)
(TokenType.TEXT, "text\n", 1, (0, 5)),
(TokenType.BLOCK, "if test", 2, (5, 18)),
(TokenType.VAR, "varvalue", 2, (18, 32)),
(TokenType.BLOCK, "endif", 2, (32, 43)),
(TokenType.COMMENT, "comment {{not a var}} {%not a block%}", 2, (43, 85)),
(TokenType.TEXT, "end text", 2, (85, 93)),
]
def test_tokenize(self):
tokens = self.lexer_class(self.template_string).tokenize()
token_tuples = [
(t.token_type, t.contents, t.lineno, t.position) for t in tokens
]
self.assertEqual(token_tuples, self.make_expected())
def make_expected(self):
raise NotImplementedError("This method must be implemented by a subclass.")
class LexerTests(LexerTestMixin, SimpleTestCase):
lexer_class = Lexer
def make_expected(self):
# The non-debug lexer does not record position.
return [t[:-1] + (None,) for t in self.expected_token_tuples]
class DebugLexerTests(LexerTestMixin, SimpleTestCase):
lexer_class = DebugLexer
def make_expected(self):
return self.expected_token_tuples
class TemplateTests(SimpleTestCase):
def test_lazy_template_string(self):
template_string = gettext_lazy("lazy string")
self.assertEqual(Template(template_string).render(Context()), template_string)
def test_repr(self):
template = Template(
"<html><body>\n"
"{% if test %}<h1>{{ varvalue }}</h1>{% endif %}"
"</body></html>"
)
self.assertEqual(
repr(template),
'<Template template_string="<html><body>{% if t...">',
)
class VariableDoesNotExistTests(SimpleTestCase):
def test_str(self):
exc = VariableDoesNotExist(msg="Failed lookup in %r", params=({"foo": "bar"},))
self.assertEqual(str(exc), "Failed lookup in {'foo': 'bar'}")
class VariableTests(SimpleTestCase):
def test_integer_literals(self):
self.assertEqual(
Variable("999999999999999999999999999").literal, 999999999999999999999999999
)
def test_nonliterals(self):
"""Variable names that aren't resolved as literals."""
for var in ["inf", "infinity", "iNFiniTy", "nan"]:
with self.subTest(var=var):
self.assertIsNone(Variable(var).literal)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_nodelist.py | tests/template_tests/test_nodelist.py | from django.template import Context, Engine
from django.template.base import TextNode, VariableNode
from django.test import SimpleTestCase
class NodelistTest(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine()
super().setUpClass()
def test_for(self):
template = self.engine.from_string("{% for i in 1 %}{{ a }}{% endfor %}")
vars = template.nodelist.get_nodes_by_type(VariableNode)
self.assertEqual(len(vars), 1)
def test_if(self):
template = self.engine.from_string("{% if x %}{{ a }}{% endif %}")
vars = template.nodelist.get_nodes_by_type(VariableNode)
self.assertEqual(len(vars), 1)
def test_ifchanged(self):
template = self.engine.from_string("{% ifchanged x %}{{ a }}{% endifchanged %}")
vars = template.nodelist.get_nodes_by_type(VariableNode)
self.assertEqual(len(vars), 1)
class TextNodeTest(SimpleTestCase):
def test_textnode_repr(self):
engine = Engine()
for temptext, reprtext in [
("Hello, world!", "<TextNode: 'Hello, world!'>"),
("One\ntwo.", "<TextNode: 'One\\ntwo.'>"),
]:
template = engine.from_string(temptext)
texts = template.nodelist.get_nodes_by_type(TextNode)
self.assertEqual(repr(texts[0]), reprtext)
class ErrorIndexTest(SimpleTestCase):
"""
Checks whether index of error is calculated correctly in
template debugger in for loops. Refs ticket #5831
"""
def test_correct_exception_index(self):
tests = [
(
"{% load bad_tag %}{% for i in range %}{% badsimpletag %}{% endfor %}",
(38, 56),
),
(
"{% load bad_tag %}{% for i in range %}{% for j in range %}"
"{% badsimpletag %}{% endfor %}{% endfor %}",
(58, 76),
),
(
"{% load bad_tag %}{% for i in range %}{% badsimpletag %}"
"{% for j in range %}Hello{% endfor %}{% endfor %}",
(38, 56),
),
(
"{% load bad_tag %}{% for i in range %}{% for j in five %}"
"{% badsimpletag %}{% endfor %}{% endfor %}",
(38, 57),
),
(
"{% load bad_tag %}{% for j in five %}{% badsimpletag %}{% endfor %}",
(18, 37),
),
]
context = Context(
{
"range": range(5),
"five": 5,
}
)
engine = Engine(
debug=True, libraries={"bad_tag": "template_tests.templatetags.bad_tag"}
)
for source, expected_error_source_index in tests:
template = engine.from_string(source)
try:
template.render(context)
except (RuntimeError, TypeError) as e:
debug = e.template_debug
self.assertEqual(
(debug["start"], debug["end"]), expected_error_source_index
)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_extends.py | tests/template_tests/test_extends.py | import os
from django.template import Context, Engine, TemplateDoesNotExist, TemplateSyntaxError
from django.test import SimpleTestCase
from .utils import ROOT, setup
RECURSIVE = os.path.join(ROOT, "recursive_templates")
class ExtendsBehaviorTests(SimpleTestCase):
def test_normal_extend(self):
engine = Engine(dirs=[os.path.join(RECURSIVE, "fs")])
template = engine.get_template("one.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one")
def test_extend_recursive(self):
engine = Engine(
dirs=[
os.path.join(RECURSIVE, "fs"),
os.path.join(RECURSIVE, "fs2"),
os.path.join(RECURSIVE, "fs3"),
]
)
template = engine.get_template("recursive.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "fs3/recursive fs2/recursive fs/recursive")
def test_extend_missing(self):
engine = Engine(dirs=[os.path.join(RECURSIVE, "fs")])
template = engine.get_template("extend-missing.html")
with self.assertRaises(TemplateDoesNotExist) as e:
template.render(Context({}))
tried = e.exception.tried
self.assertEqual(len(tried), 1)
self.assertEqual(tried[0][0].template_name, "missing.html")
def test_recursive_multiple_loaders(self):
engine = Engine(
dirs=[os.path.join(RECURSIVE, "fs")],
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"one.html": (
'{% extends "one.html" %}{% block content %}'
"{{ block.super }} locmem-one{% endblock %}"
),
"two.html": (
'{% extends "two.html" %}{% block content %}'
"{{ block.super }} locmem-two{% endblock %}"
),
"three.html": (
'{% extends "three.html" %}{% block content %}'
"{{ block.super }} locmem-three{% endblock %}"
),
},
),
"django.template.loaders.filesystem.Loader",
],
)
template = engine.get_template("one.html")
output = template.render(Context({}))
self.assertEqual(
output.strip(), "three locmem-three two locmem-two one locmem-one"
)
def test_extend_self_error(self):
"""
Catch if a template extends itself and no other matching
templates are found.
"""
engine = Engine(dirs=[os.path.join(RECURSIVE, "fs")])
template = engine.get_template("self.html")
with self.assertRaises(TemplateDoesNotExist) as e:
template.render(Context({}))
tried = e.exception.tried
self.assertEqual(len(tried), 1)
origin, message = tried[0]
self.assertEqual(origin.template_name, "self.html")
self.assertEqual(message, "Skipped to avoid recursion")
def test_extend_cached(self):
engine = Engine(
dirs=[
os.path.join(RECURSIVE, "fs"),
os.path.join(RECURSIVE, "fs2"),
os.path.join(RECURSIVE, "fs3"),
],
loaders=[
(
"django.template.loaders.cached.Loader",
[
"django.template.loaders.filesystem.Loader",
],
),
],
)
template = engine.get_template("recursive.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "fs3/recursive fs2/recursive fs/recursive")
cache = engine.template_loaders[0].get_template_cache
self.assertEqual(len(cache), 3)
expected_path = os.path.join("fs", "recursive.html")
self.assertTrue(cache["recursive.html"].origin.name.endswith(expected_path))
# Render another path that uses the same templates from the cache
template = engine.get_template("other-recursive.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "fs3/recursive fs2/recursive fs/recursive")
# Template objects should not be duplicated.
self.assertEqual(len(cache), 4)
expected_path = os.path.join("fs", "other-recursive.html")
self.assertTrue(
cache["other-recursive.html"].origin.name.endswith(expected_path)
)
def test_unique_history_per_loader(self):
"""
Extending should continue even if two loaders return the same
name for a template.
"""
engine = Engine(
loaders=[
[
"django.template.loaders.locmem.Loader",
{
"base.html": (
'{% extends "base.html" %}{% block content %}'
"{{ block.super }} loader1{% endblock %}"
),
},
],
[
"django.template.loaders.locmem.Loader",
{
"base.html": "{% block content %}loader2{% endblock %}",
},
],
]
)
template = engine.get_template("base.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "loader2 loader1")
def test_block_override_in_extended_included_template(self):
"""
ExtendsNode.find_template() initializes history with self.origin
(#28071).
"""
engine = Engine(
loaders=[
[
"django.template.loaders.locmem.Loader",
{
"base.html": (
"{% extends 'base.html' %}{% block base %}{{ block.super }}"
"2{% endblock %}"
),
"included.html": (
"{% extends 'included.html' %}{% block included %}"
"{{ block.super }}B{% endblock %}"
),
},
],
[
"django.template.loaders.locmem.Loader",
{
"base.html": (
"{% block base %}1{% endblock %}"
"{% include 'included.html' %}"
),
"included.html": "{% block included %}A{% endblock %}",
},
],
],
)
template = engine.get_template("base.html")
self.assertEqual(template.render(Context({})), "12AB")
@setup(
{"index.html": "{% block content %}B{% endblock %}{% extends 'base.html' %}"}
)
def test_extends_not_first_tag_in_extended_template(self):
msg = "{% extends 'base.html' %} must be the first tag in 'index.html'."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
self.engine.get_template("index.html")
def test_extends_not_first_tag_in_extended_template_from_string(self):
template_string = "{% block content %}B{% endblock %}{% extends 'base.html' %}"
msg = "{% extends 'base.html' %} must be the first tag in the template."
with self.assertRaisesMessage(TemplateSyntaxError, msg):
Engine().from_string(template_string)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_custom.py | tests/template_tests/test_custom.py | import os
from django.template import Context, Engine, TemplateSyntaxError
from django.template.base import Node
from django.template.library import InvalidTemplateLibrary, Library
from django.test import SimpleTestCase
from django.test.utils import extend_sys_path
from .templatetags import custom, inclusion
from .utils import ROOT
LIBRARIES = {
"custom": "template_tests.templatetags.custom",
"inclusion": "template_tests.templatetags.inclusion",
}
class CustomFilterTests(SimpleTestCase):
def test_filter(self):
engine = Engine(libraries=LIBRARIES)
t = engine.from_string("{% load custom %}{{ string|trim:5 }}")
self.assertEqual(
t.render(Context({"string": "abcdefghijklmnopqrstuvwxyz"})), "abcde"
)
def test_decorated_filter(self):
engine = Engine(libraries=LIBRARIES)
t = engine.from_string("{% load custom %}{{ name|make_data_div }}")
self.assertEqual(
t.render(Context({"name": "foo"})), '<div data-name="foo"></div>'
)
class TagTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine(app_dirs=True, libraries=LIBRARIES)
super().setUpClass()
def verify_tag(self, tag, name):
self.assertEqual(tag.__name__, name)
self.assertEqual(tag.__doc__, "Expected %s __doc__" % name)
self.assertEqual(tag.__dict__["anything"], "Expected %s __dict__" % name)
class SimpleTagTests(TagTestCase):
def test_simple_tags(self):
c = Context({"value": 42})
templates = [
("{% load custom %}{% no_params %}", "no_params - Expected result"),
("{% load custom %}{% one_param 37 %}", "one_param - Expected result: 37"),
(
"{% load custom %}{% explicit_no_context 37 %}",
"explicit_no_context - Expected result: 37",
),
(
"{% load custom %}{% no_params_with_context %}",
"no_params_with_context - Expected result (context value: 42)",
),
(
"{% load custom %}{% params_and_context 37 %}",
"params_and_context - Expected result (context value: 42): 37",
),
(
"{% load custom %}{% simple_two_params 37 42 %}",
"simple_two_params - Expected result: 37, 42",
),
(
"{% load custom %}{% simple_keyword_only_param kwarg=37 %}",
"simple_keyword_only_param - Expected result: 37",
),
(
"{% load custom %}{% simple_keyword_only_default %}",
"simple_keyword_only_default - Expected result: 42",
),
(
"{% load custom %}{% simple_keyword_only_default kwarg=37 %}",
"simple_keyword_only_default - Expected result: 37",
),
(
"{% load custom %}{% simple_one_default 37 %}",
"simple_one_default - Expected result: 37, hi",
),
(
'{% load custom %}{% simple_one_default 37 two="hello" %}',
"simple_one_default - Expected result: 37, hello",
),
(
'{% load custom %}{% simple_one_default one=99 two="hello" %}',
"simple_one_default - Expected result: 99, hello",
),
(
"{% load custom %}{% simple_one_default 37 42 %}",
"simple_one_default - Expected result: 37, 42",
),
(
"{% load custom %}{% simple_unlimited_args 37 %}",
"simple_unlimited_args - Expected result: 37, hi",
),
(
"{% load custom %}{% simple_unlimited_args 37 42 56 89 %}",
"simple_unlimited_args - Expected result: 37, 42, 56, 89",
),
(
"{% load custom %}{% simple_only_unlimited_args %}",
"simple_only_unlimited_args - Expected result: ",
),
(
"{% load custom %}{% simple_only_unlimited_args 37 42 56 89 %}",
"simple_only_unlimited_args - Expected result: 37, 42, 56, 89",
),
(
"{% load custom %}"
'{% simple_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" '
"four=1|add:3 %}",
"simple_unlimited_args_kwargs - Expected result: 37, 42, 56 / "
"eggs=scrambled, four=4",
),
]
for entry in templates:
t = self.engine.from_string(entry[0])
self.assertEqual(t.render(c), entry[1])
for entry in templates:
t = self.engine.from_string(
"%s as var %%}Result: {{ var }}" % entry[0][0:-2]
)
self.assertEqual(t.render(c), "Result: %s" % entry[1])
def test_simple_tag_errors(self):
errors = [
(
"'simple_one_default' received unexpected keyword argument 'three'",
'{% load custom %}{% simple_one_default 99 two="hello" three="foo" %}',
),
(
"'simple_two_params' received too many positional arguments",
"{% load custom %}{% simple_two_params 37 42 56 %}",
),
(
"'simple_one_default' received too many positional arguments",
"{% load custom %}{% simple_one_default 37 42 56 %}",
),
(
"'simple_keyword_only_param' did not receive value(s) for the "
"argument(s): 'kwarg'",
"{% load custom %}{% simple_keyword_only_param %}",
),
(
"'simple_keyword_only_param' received multiple values for "
"keyword argument 'kwarg'",
"{% load custom %}{% simple_keyword_only_param kwarg=42 kwarg=37 %}",
),
(
"'simple_keyword_only_default' received multiple values for "
"keyword argument 'kwarg'",
"{% load custom %}{% simple_keyword_only_default kwarg=42 "
"kwarg=37 %}",
),
(
"'simple_unlimited_args_kwargs' received some positional argument(s) "
"after some keyword argument(s)",
"{% load custom %}"
"{% simple_unlimited_args_kwargs 37 40|add:2 "
'eggs="scrambled" 56 four=1|add:3 %}',
),
(
"'simple_unlimited_args_kwargs' received multiple values for keyword "
"argument 'eggs'",
"{% load custom %}"
"{% simple_unlimited_args_kwargs 37 "
'eggs="scrambled" eggs="scrambled" %}',
),
]
for entry in errors:
with self.assertRaisesMessage(TemplateSyntaxError, entry[0]):
self.engine.from_string(entry[1])
for entry in errors:
with self.assertRaisesMessage(TemplateSyntaxError, entry[0]):
self.engine.from_string("%s as var %%}" % entry[1][0:-2])
def test_simple_tag_escaping_autoescape_off(self):
c = Context({"name": "Jack & Jill"}, autoescape=False)
t = self.engine.from_string("{% load custom %}{% escape_naive %}")
self.assertEqual(t.render(c), "Hello Jack & Jill!")
def test_simple_tag_naive_escaping(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string("{% load custom %}{% escape_naive %}")
self.assertEqual(t.render(c), "Hello Jack & Jill!")
def test_simple_tag_explicit_escaping(self):
# Check we don't double escape
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string("{% load custom %}{% escape_explicit %}")
self.assertEqual(t.render(c), "Hello Jack & Jill!")
def test_simple_tag_format_html_escaping(self):
# Check we don't double escape
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string("{% load custom %}{% escape_format_html %}")
self.assertEqual(t.render(c), "Hello Jack & Jill!")
def test_simple_tag_registration(self):
# The decorators preserve the decorated function's docstring, name,
# and attributes.
self.verify_tag(custom.no_params, "no_params")
self.verify_tag(custom.one_param, "one_param")
self.verify_tag(custom.explicit_no_context, "explicit_no_context")
self.verify_tag(custom.no_params_with_context, "no_params_with_context")
self.verify_tag(custom.params_and_context, "params_and_context")
self.verify_tag(
custom.simple_unlimited_args_kwargs, "simple_unlimited_args_kwargs"
)
def test_simple_tag_missing_context(self):
# The 'context' parameter must be present when takes_context is True
msg = (
"'simple_tag_without_context_parameter' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_tag(takes_context=True)
def simple_tag_without_context_parameter(arg):
return "Expected result"
def test_simple_tag_missing_context_no_params(self):
msg = (
"'simple_tag_takes_context_without_params' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_tag(takes_context=True)
def simple_tag_takes_context_without_params():
return "Expected result"
class SimpleBlockTagTests(TagTestCase):
def test_simple_block_tags(self):
c = Context({"value": 42})
templates = [
(
"{% load custom %}{% div %}content{% enddiv %}",
"<div id='test'>content</div>",
),
(
"{% load custom %}{% one_param_block 37 %}inner"
"{% endone_param_block %}",
"one_param_block - Expected result: 37 with content inner",
),
(
"{% load custom %}{% explicit_no_context_block 37 %}inner"
"{% endexplicit_no_context_block %}",
"explicit_no_context_block - Expected result: 37 with content inner",
),
(
"{% load custom %}{% no_params_with_context_block %}inner"
"{% endno_params_with_context_block %}",
"no_params_with_context_block - Expected result (context value: 42) "
"(content value: inner)",
),
(
"{% load custom %}{% params_and_context_block 37 %}inner"
"{% endparams_and_context_block %}",
"params_and_context_block - Expected result (context value: 42) "
"(content value: inner): 37",
),
(
"{% load custom %}{% simple_two_params_block 37 42 %}inner"
"{% endsimple_two_params_block %}",
"simple_two_params_block - Expected result (content value: inner): "
"37, 42",
),
(
"{% load custom %}{% simple_keyword_only_param_block kwarg=37 %}thirty "
"seven{% endsimple_keyword_only_param_block %}",
"simple_keyword_only_param_block - Expected result (content value: "
"thirty seven): 37",
),
(
"{% load custom %}{% simple_keyword_only_default_block %}forty two"
"{% endsimple_keyword_only_default_block %}",
"simple_keyword_only_default_block - Expected result (content value: "
"forty two): 42",
),
(
"{% load custom %}{% simple_keyword_only_default_block kwarg=37 %}"
"thirty seven{% endsimple_keyword_only_default_block %}",
"simple_keyword_only_default_block - Expected result (content value: "
"thirty seven): 37",
),
(
"{% load custom %}{% simple_one_default_block 37 %}inner"
"{% endsimple_one_default_block %}",
"simple_one_default_block - Expected result (content value: inner): "
"37, hi",
),
(
'{% load custom %}{% simple_one_default_block 37 two="hello" %}inner'
"{% endsimple_one_default_block %}",
"simple_one_default_block - Expected result (content value: inner): "
"37, hello",
),
(
'{% load custom %}{% simple_one_default_block one=99 two="hello" %}'
"inner{% endsimple_one_default_block %}",
"simple_one_default_block - Expected result (content value: inner): "
"99, hello",
),
(
"{% load custom %}{% simple_one_default_block 37 42 %}inner"
"{% endsimple_one_default_block %}",
"simple_one_default_block - Expected result (content value: inner): "
"37, 42",
),
(
"{% load custom %}{% simple_unlimited_args_block 37 %}thirty seven"
"{% endsimple_unlimited_args_block %}",
"simple_unlimited_args_block - Expected result (content value: thirty "
"seven): 37, hi",
),
(
"{% load custom %}{% simple_unlimited_args_block 37 42 56 89 %}numbers"
"{% endsimple_unlimited_args_block %}",
"simple_unlimited_args_block - Expected result "
"(content value: numbers): 37, 42, 56, 89",
),
(
"{% load custom %}{% simple_only_unlimited_args_block %}inner"
"{% endsimple_only_unlimited_args_block %}",
"simple_only_unlimited_args_block - Expected result (content value: "
"inner): ",
),
(
"{% load custom %}{% simple_only_unlimited_args_block 37 42 56 89 %}"
"numbers{% endsimple_only_unlimited_args_block %}",
"simple_only_unlimited_args_block - Expected result "
"(content value: numbers): 37, 42, 56, 89",
),
(
"{% load custom %}"
'{% simple_unlimited_args_kwargs_block 37 40|add:2 56 eggs="scrambled" '
"four=1|add:3 %}inner content"
"{% endsimple_unlimited_args_kwargs_block %}",
"simple_unlimited_args_kwargs_block - Expected result (content value: "
"inner content): 37, 42, 56 / eggs=scrambled, four=4",
),
]
for entry in templates:
with self.subTest(entry[0]):
t = self.engine.from_string(entry[0])
self.assertEqual(t.render(c), entry[1])
def test_simple_block_tag_errors(self):
errors = [
(
"'simple_one_default_block' received unexpected keyword argument "
"'three'",
"{% load custom %}"
'{% simple_one_default_block 99 two="hello" three="foo" %}'
"{% endsimple_one_default_block %}",
),
(
"'simple_two_params_block' received too many positional arguments",
"{% load custom %}{% simple_two_params_block 37 42 56 %}"
"{% endsimple_two_params_block %}",
),
(
"'simple_one_default_block' received too many positional arguments",
"{% load custom %}{% simple_one_default_block 37 42 56 %}"
"{% endsimple_one_default_block %}",
),
(
"'simple_keyword_only_param_block' did not receive value(s) for the "
"argument(s): 'kwarg'",
"{% load custom %}{% simple_keyword_only_param_block %}"
"{% endsimple_keyword_only_param_block %}",
),
(
"'simple_keyword_only_param_block' received multiple values for "
"keyword argument 'kwarg'",
"{% load custom %}"
"{% simple_keyword_only_param_block kwarg=42 kwarg=37 %}"
"{% endsimple_keyword_only_param_block %}",
),
(
"'simple_keyword_only_default_block' received multiple values for "
"keyword argument 'kwarg'",
"{% load custom %}{% simple_keyword_only_default_block kwarg=42 "
"kwarg=37 %}{% endsimple_keyword_only_default_block %}",
),
(
"'simple_unlimited_args_kwargs_block' received some positional "
"argument(s) after some keyword argument(s)",
"{% load custom %}"
'{% simple_unlimited_args_kwargs_block 37 40|add:2 eggs="scrambled" 56 '
"four=1|add:3 %}{% endsimple_unlimited_args_kwargs_block %}",
),
(
"'simple_unlimited_args_kwargs_block' received multiple values for "
"keyword argument 'eggs'",
"{% load custom %}"
"{% simple_unlimited_args_kwargs_block 37 "
'eggs="scrambled" eggs="scrambled" %}'
"{% endsimple_unlimited_args_kwargs_block %}",
),
(
"Unclosed tag on line 1: 'div'. Looking for one of: enddiv.",
"{% load custom %}{% div %}Some content",
),
(
"Unclosed tag on line 1: 'simple_one_default_block'. Looking for one "
"of: endsimple_one_default_block.",
"{% load custom %}{% simple_one_default_block %}Some content",
),
]
for entry in errors:
with self.subTest(entry[1]):
with self.assertRaisesMessage(TemplateSyntaxError, entry[0]):
self.engine.from_string(entry[1])
def test_simple_block_tag_escaping_autoescape_off(self):
c = Context({"name": "Jack & Jill"}, autoescape=False)
t = self.engine.from_string(
"{% load custom %}{% escape_naive_block %}{{ name }} again"
"{% endescape_naive_block %}"
)
self.assertEqual(t.render(c), "Hello Jack & Jill: Jack & Jill again!")
def test_simple_block_tag_naive_escaping(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}{% escape_naive_block %}{{ name }} again"
"{% endescape_naive_block %}"
)
self.assertEqual(
t.render(c), "Hello Jack & Jill: Jack &amp; Jill again!"
)
def test_simple_block_tag_explicit_escaping(self):
# Check we don't double escape
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}{% escape_explicit_block %}again"
"{% endescape_explicit_block %}"
)
self.assertEqual(t.render(c), "Hello Jack & Jill: again!")
def test_simple_block_tag_format_html_escaping(self):
# Check we don't double escape
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}{% escape_format_html_block %}again"
"{% endescape_format_html_block %}"
)
self.assertEqual(t.render(c), "Hello Jack & Jill: again!")
def test_simple_block_tag_missing_context(self):
# The 'context' parameter must be present when takes_context is True
msg = (
"'simple_block_tag_without_context_parameter' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_block_tag(takes_context=True)
def simple_block_tag_without_context_parameter(arg):
return "Expected result"
def test_simple_block_tag_missing_context_no_params(self):
msg = (
"'simple_tag_takes_context_without_params_block' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_block_tag(takes_context=True)
def simple_tag_takes_context_without_params_block():
return "Expected result"
def test_simple_block_tag_missing_content(self):
# The 'content' parameter must be present when takes_context is True
msg = (
"'simple_block_tag_without_content' must have a first argument of 'content'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_block_tag
def simple_block_tag_without_content():
return "Expected result"
def test_simple_block_tag_with_context_missing_content(self):
# The 'content' parameter must be present when takes_context is True
msg = (
"'simple_block_tag_with_context_without_content' is decorated with "
"takes_context=True so it must have a first argument of 'context' and a "
"second argument of 'content'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().simple_block_tag(takes_context=True)
def simple_block_tag_with_context_without_content():
return "Expected result"
def test_simple_block_gets_context(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string("{% load custom %}{% div %}{{ name }}{% enddiv %}")
self.assertEqual(t.render(c), "<div id='test'>Jack & Jill</div>")
def test_simple_block_capture_as(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}{% div as div_content %}{{ name }}{% enddiv %}"
"My div is: {{ div_content }}"
)
self.assertEqual(t.render(c), "My div is: <div id='test'>Jack & Jill</div>")
def test_simple_block_nested(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}Start{% div id='outer' %}Before{% div id='inner' %}"
"{{ name }}{% enddiv %}After{% enddiv %}End"
)
self.assertEqual(
t.render(c),
"Start<div id='outer'>Before<div id='inner'>Jack & Jill</div>After"
"</div>End",
)
def test_different_simple_block_nested(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}Start{% div id='outer' %}Before"
"{% simple_keyword_only_default_block %}Inner"
"{% endsimple_keyword_only_default_block %}"
"After{% enddiv %}End"
)
self.assertEqual(
t.render(c),
"Start<div id='outer'>Before"
"simple_keyword_only_default_block - Expected result (content value: "
"Inner): 42After</div>End",
)
def test_custom_end_tag(self):
c = Context({"name": "Jack & Jill"})
t = self.engine.from_string(
"{% load custom %}{% div_custom_end %}{{ name }}{% divend %}"
)
self.assertEqual(t.render(c), "<div>Jack & Jill</div>")
with self.assertRaisesMessage(
TemplateSyntaxError,
"'enddiv_custom_end', expected 'divend'. Did you forget to register or "
"load this tag?",
):
self.engine.from_string(
"{% load custom %}{% div_custom_end %}{{ name }}{% enddiv_custom_end %}"
)
class InclusionTagTests(TagTestCase):
def test_inclusion_tags(self):
c = Context({"value": 42})
templates = [
(
"{% load inclusion %}{% inclusion_no_params %}",
"inclusion_no_params - Expected result\n",
),
(
"{% load inclusion %}{% inclusion_one_param 37 %}",
"inclusion_one_param - Expected result: 37\n",
),
(
"{% load inclusion %}{% inclusion_explicit_no_context 37 %}",
"inclusion_explicit_no_context - Expected result: 37\n",
),
(
"{% load inclusion %}{% inclusion_no_params_with_context %}",
"inclusion_no_params_with_context - Expected result (context value: "
"42)\n",
),
(
"{% load inclusion %}{% inclusion_params_and_context 37 %}",
"inclusion_params_and_context - Expected result (context value: 42): "
"37\n",
),
(
"{% load inclusion %}{% inclusion_two_params 37 42 %}",
"inclusion_two_params - Expected result: 37, 42\n",
),
(
"{% load inclusion %}{% inclusion_one_default 37 %}",
"inclusion_one_default - Expected result: 37, hi\n",
),
(
'{% load inclusion %}{% inclusion_one_default 37 two="hello" %}',
"inclusion_one_default - Expected result: 37, hello\n",
),
(
'{% load inclusion %}{% inclusion_one_default one=99 two="hello" %}',
"inclusion_one_default - Expected result: 99, hello\n",
),
(
"{% load inclusion %}{% inclusion_one_default 37 42 %}",
"inclusion_one_default - Expected result: 37, 42\n",
),
(
"{% load inclusion %}{% inclusion_keyword_only_default kwarg=37 %}",
"inclusion_keyword_only_default - Expected result: 37\n",
),
(
"{% load inclusion %}{% inclusion_unlimited_args 37 %}",
"inclusion_unlimited_args - Expected result: 37, hi\n",
),
(
"{% load inclusion %}{% inclusion_unlimited_args 37 42 56 89 %}",
"inclusion_unlimited_args - Expected result: 37, 42, 56, 89\n",
),
(
"{% load inclusion %}{% inclusion_only_unlimited_args %}",
"inclusion_only_unlimited_args - Expected result: \n",
),
(
"{% load inclusion %}{% inclusion_only_unlimited_args 37 42 56 89 %}",
"inclusion_only_unlimited_args - Expected result: 37, 42, 56, 89\n",
),
(
"{% load inclusion %}"
'{% inclusion_unlimited_args_kwargs 37 40|add:2 56 eggs="scrambled" '
"four=1|add:3 %}",
"inclusion_unlimited_args_kwargs - Expected result: 37, 42, 56 / "
"eggs=scrambled, four=4\n",
),
]
for entry in templates:
t = self.engine.from_string(entry[0])
self.assertEqual(t.render(c), entry[1])
def test_inclusion_tag_errors(self):
errors = [
(
"'inclusion_one_default' received unexpected keyword argument 'three'",
"{% load inclusion %}"
'{% inclusion_one_default 99 two="hello" three="foo" %}',
),
(
"'inclusion_two_params' received too many positional arguments",
"{% load inclusion %}{% inclusion_two_params 37 42 56 %}",
),
(
"'inclusion_one_default' received too many positional arguments",
"{% load inclusion %}{% inclusion_one_default 37 42 56 %}",
),
(
"'inclusion_one_default' did not receive value(s) for the argument(s): "
"'one'",
"{% load inclusion %}{% inclusion_one_default %}",
),
(
"'inclusion_keyword_only_default' received multiple values "
"for keyword argument 'kwarg'",
"{% load inclusion %}{% inclusion_keyword_only_default "
"kwarg=37 kwarg=42 %}",
),
(
"'inclusion_unlimited_args' did not receive value(s) for the "
"argument(s): 'one'",
"{% load inclusion %}{% inclusion_unlimited_args %}",
),
(
"'inclusion_unlimited_args_kwargs' received some positional "
"argument(s) after some keyword argument(s)",
"{% load inclusion %}"
"{% inclusion_unlimited_args_kwargs 37 40|add:2 "
'eggs="boiled" 56 four=1|add:3 %}',
),
(
"'inclusion_unlimited_args_kwargs' received multiple values for "
"keyword argument 'eggs'",
"{% load inclusion %}"
"{% inclusion_unlimited_args_kwargs 37 "
'eggs="scrambled" eggs="scrambled" %}',
),
]
for entry in errors:
with self.assertRaisesMessage(TemplateSyntaxError, entry[0]):
self.engine.from_string(entry[1])
def test_include_tag_missing_context(self):
# The 'context' parameter must be present when takes_context is True
msg = (
"'inclusion_tag_without_context_parameter' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().inclusion_tag("inclusion.html", takes_context=True)
def inclusion_tag_without_context_parameter(arg):
return {}
def test_include_tag_missing_context_no_params(self):
msg = (
"'inclusion_tag_takes_context_without_params' is decorated with "
"takes_context=True so it must have a first argument of 'context'"
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
@Library().inclusion_tag("inclusion.html", takes_context=True)
def inclusion_tag_takes_context_without_params():
return {}
def test_inclusion_tags_from_template(self):
c = Context({"value": 42})
templates = [
(
"{% load inclusion %}{% inclusion_no_params_from_template %}",
"inclusion_no_params_from_template - Expected result\n",
),
(
"{% load inclusion %}{% inclusion_one_param_from_template 37 %}",
"inclusion_one_param_from_template - Expected result: 37\n",
),
(
"{% load inclusion %}"
"{% inclusion_explicit_no_context_from_template 37 %}",
"inclusion_explicit_no_context_from_template - Expected result: 37\n",
),
(
"{% load inclusion %}"
"{% inclusion_no_params_with_context_from_template %}",
"inclusion_no_params_with_context_from_template - Expected result "
"(context value: 42)\n",
),
(
"{% load inclusion %}"
"{% inclusion_params_and_context_from_template 37 %}",
"inclusion_params_and_context_from_template - Expected result (context "
"value: 42): 37\n",
),
(
"{% load inclusion %}{% inclusion_two_params_from_template 37 42 %}",
"inclusion_two_params_from_template - Expected result: 37, 42\n",
),
(
"{% load inclusion %}{% inclusion_one_default_from_template 37 %}",
"inclusion_one_default_from_template - Expected result: 37, hi\n",
),
(
"{% load inclusion %}{% inclusion_one_default_from_template 37 42 %}",
"inclusion_one_default_from_template - Expected result: 37, 42\n",
),
(
"{% load inclusion %}{% inclusion_unlimited_args_from_template 37 %}",
"inclusion_unlimited_args_from_template - Expected result: 37, hi\n",
),
(
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | true |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_extends_relative.py | tests/template_tests/test_extends_relative.py | import os
from django.template import Context, Engine, TemplateSyntaxError
from django.test import SimpleTestCase
from .utils import ROOT
RELATIVE = os.path.join(ROOT, "relative_templates")
class ExtendsRelativeBehaviorTests(SimpleTestCase):
def test_normal_extend(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("one.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one")
def test_normal_extend_variable(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("one_var.html")
output = template.render(Context({"tmpl": "./two.html"}))
self.assertEqual(output.strip(), "three two one")
def test_dir1_extend(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/one.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir1 one")
def test_dir1_extend1(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/one1.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir1 one")
def test_dir1_extend2(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/one2.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir1 one")
def test_dir1_extend3(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/one3.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir1 one")
def test_dir2_extend(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/dir2/one.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir2 one")
def test_extend_error(self):
engine = Engine(dirs=[RELATIVE])
msg = (
"The relative path '\"./../two.html\"' points outside the file "
"hierarchy that template 'error_extends.html' is in."
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
engine.render_to_string("error_extends.html")
class IncludeRelativeBehaviorTests(SimpleTestCase):
def test_normal_include(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/dir2/inc2.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "dir2 include")
def test_normal_include_variable(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/dir2/inc3.html")
output = template.render(Context({"tmpl": "./include_content.html"}))
self.assertEqual(output.strip(), "dir2 include")
def test_dir2_include(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/dir2/inc1.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three")
def test_include_error(self):
engine = Engine(dirs=[RELATIVE])
msg = (
"The relative path '\"./../three.html\"' points outside the file "
"hierarchy that template 'error_include.html' is in."
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
engine.render_to_string("error_include.html")
class ExtendsMixedBehaviorTests(SimpleTestCase):
def test_mixing1(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/two.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three two one dir2 one dir1 two")
def test_mixing2(self):
engine = Engine(dirs=[RELATIVE])
template = engine.get_template("dir1/three.html")
output = template.render(Context({}))
self.assertEqual(output.strip(), "three dir1 three")
def test_mixing_loop(self):
engine = Engine(dirs=[RELATIVE])
msg = (
"The relative path '\"./dir2/../looped.html\"' was translated to "
"template name 'dir1/looped.html', the same template in which "
"the tag appears."
)
with self.assertRaisesMessage(TemplateSyntaxError, msg):
engine.render_to_string("dir1/looped.html")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/annotated_tag_function.py | tests/template_tests/annotated_tag_function.py | from django import template
register = template.Library()
@register.simple_tag()
def annotated_tag_function(val: int):
return val
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_context.py | tests/template_tests/test_context.py | from copy import copy
from unittest import mock
from django.http import HttpRequest
from django.template import (
Context,
Engine,
RequestContext,
Template,
Variable,
VariableDoesNotExist,
)
from django.template.context import RenderContext
from django.test import RequestFactory, SimpleTestCase, override_settings
class ContextTests(SimpleTestCase):
def test_context(self):
c = Context({"a": 1, "b": "xyzzy"})
self.assertEqual(c["a"], 1)
self.assertEqual(c.push(), {})
c["a"] = 2
self.assertEqual(c["a"], 2)
self.assertEqual(c.get("a"), 2)
self.assertEqual(c.pop(), {"a": 2})
self.assertEqual(c["a"], 1)
self.assertEqual(c.get("foo", 42), 42)
self.assertEqual(c, mock.ANY)
def test_push_context_manager(self):
c = Context({"a": 1})
with c.push():
c["a"] = 2
self.assertEqual(c["a"], 2)
self.assertEqual(c["a"], 1)
with c.push(a=3):
self.assertEqual(c["a"], 3)
self.assertEqual(c["a"], 1)
def test_update_context_manager(self):
c = Context({"a": 1})
with c.update({}):
c["a"] = 2
self.assertEqual(c["a"], 2)
self.assertEqual(c["a"], 1)
with c.update({"a": 3}):
self.assertEqual(c["a"], 3)
self.assertEqual(c["a"], 1)
def test_push_context_manager_with_context_object(self):
c = Context({"a": 1})
with c.push(Context({"a": 3})):
self.assertEqual(c["a"], 3)
self.assertEqual(c["a"], 1)
def test_update_context_manager_with_context_object(self):
c = Context({"a": 1})
with c.update(Context({"a": 3})):
self.assertEqual(c["a"], 3)
self.assertEqual(c["a"], 1)
def test_push_proper_layering(self):
c = Context({"a": 1})
c.push(Context({"b": 2}))
c.push(Context({"c": 3, "d": {"z": "26"}}))
self.assertEqual(
c.dicts,
[
{"False": False, "None": None, "True": True},
{"a": 1},
{"b": 2},
{"c": 3, "d": {"z": "26"}},
],
)
def test_update_proper_layering(self):
c = Context({"a": 1})
c.update(Context({"b": 2}))
c.update(Context({"c": 3, "d": {"z": "26"}}))
self.assertEqual(
c.dicts,
[
{"False": False, "None": None, "True": True},
{"a": 1},
{"b": 2},
{"c": 3, "d": {"z": "26"}},
],
)
def test_setdefault(self):
c = Context()
x = c.setdefault("x", 42)
self.assertEqual(x, 42)
self.assertEqual(c["x"], 42)
x = c.setdefault("x", 100)
self.assertEqual(x, 42)
self.assertEqual(c["x"], 42)
def test_resolve_on_context_method(self):
"""
#17778 -- Variable shouldn't resolve RequestContext methods
"""
empty_context = Context()
with self.assertRaises(VariableDoesNotExist):
Variable("no_such_variable").resolve(empty_context)
with self.assertRaises(VariableDoesNotExist):
Variable("new").resolve(empty_context)
self.assertEqual(
Variable("new").resolve(Context({"new": "foo"})),
"foo",
)
def test_render_context(self):
test_context = RenderContext({"fruit": "papaya"})
# push() limits access to the topmost dict
test_context.push()
test_context["vegetable"] = "artichoke"
self.assertEqual(list(test_context), ["vegetable"])
self.assertNotIn("fruit", test_context)
with self.assertRaises(KeyError):
test_context["fruit"]
self.assertIsNone(test_context.get("fruit"))
def test_flatten_context(self):
a = Context()
a.update({"a": 2})
a.update({"b": 4})
a.update({"c": 8})
self.assertEqual(
a.flatten(),
{"False": False, "None": None, "True": True, "a": 2, "b": 4, "c": 8},
)
def test_flatten_context_with_context(self):
"""
Context.push() with a Context argument should work.
"""
a = Context({"a": 2})
a.push(Context({"z": "8"}))
self.assertEqual(
a.flatten(),
{
"False": False,
"None": None,
"True": True,
"a": 2,
"z": "8",
},
)
def test_flatten_context_with_context_copy(self):
ctx1 = Context({"a": 2})
ctx2 = ctx1.new(Context({"b": 4}))
self.assertEqual(
ctx2.dicts, [{"True": True, "False": False, "None": None}, {"b": 4}]
)
self.assertEqual(
ctx2.flatten(),
{"False": False, "None": None, "True": True, "b": 4},
)
def test_context_comparable(self):
"""
#21765 -- equality comparison should work
"""
test_data = {"x": "y", "v": "z", "d": {"o": object, "a": "b"}}
self.assertEqual(Context(test_data), Context(test_data))
a = Context()
b = Context()
self.assertEqual(a, b)
# update only a
a.update({"a": 1})
self.assertNotEqual(a, b)
# update both to check regression
a.update({"c": 3})
b.update({"c": 3})
self.assertNotEqual(a, b)
# make contexts equals again
b.update({"a": 1})
self.assertEqual(a, b)
def test_copy_request_context_twice(self):
"""
#24273 -- Copy twice shouldn't raise an exception
"""
RequestContext(HttpRequest()).new().new()
def test_set_upward(self):
c = Context({"a": 1})
c.set_upward("a", 2)
self.assertEqual(c.get("a"), 2)
def test_set_upward_empty_context(self):
empty_context = Context()
empty_context.set_upward("a", 1)
self.assertEqual(empty_context.get("a"), 1)
def test_set_upward_with_push(self):
"""
The highest context which has the given key is used.
"""
c = Context({"a": 1})
c.push({"a": 2})
c.set_upward("a", 3)
self.assertEqual(c.get("a"), 3)
c.pop()
self.assertEqual(c.get("a"), 1)
def test_set_upward_with_push_no_match(self):
"""
The highest context is used if the given key isn't found.
"""
c = Context({"b": 1})
c.push({"b": 2})
c.set_upward("a", 2)
self.assertEqual(len(c.dicts), 3)
self.assertEqual(c.dicts[-1]["a"], 2)
def context_process_returning_none(request):
return None
class RequestContextTests(SimpleTestCase):
request_factory = RequestFactory()
def test_include_only(self):
"""
#15721 -- ``{% include %}`` and ``RequestContext`` should work
together.
"""
engine = Engine(
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"child": '{{ var|default:"none" }}',
},
),
]
)
request = self.request_factory.get("/")
ctx = RequestContext(request, {"var": "parent"})
self.assertEqual(
engine.from_string('{% include "child" %}').render(ctx), "parent"
)
self.assertEqual(
engine.from_string('{% include "child" only %}').render(ctx), "none"
)
def test_stack_size(self):
"""Optimized RequestContext construction (#7116)."""
request = self.request_factory.get("/")
ctx = RequestContext(request, {})
# The stack contains 4 items:
# [builtins, supplied context, context processor, empty dict]
self.assertEqual(len(ctx.dicts), 4)
def test_context_comparable(self):
# Create an engine without any context processors.
test_data = {"x": "y", "v": "z", "d": {"o": object, "a": "b"}}
# test comparing RequestContext to prevent problems if somebody
# adds __eq__ in the future
request = self.request_factory.get("/")
self.assertEqual(
RequestContext(request, dict_=test_data),
RequestContext(request, dict_=test_data),
)
def test_modify_context_and_render(self):
template = Template("{{ foo }}")
request = self.request_factory.get("/")
context = RequestContext(request, {})
context["foo"] = "foo"
self.assertEqual(template.render(context), "foo")
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"OPTIONS": {
"context_processors": [
"django.template.context_processors.request",
"template_tests.test_context.context_process_returning_none",
],
},
}
],
)
def test_template_context_processor_returning_none(self):
request_context = RequestContext(HttpRequest())
msg = (
"Context processor context_process_returning_none didn't return a "
"dictionary."
)
with self.assertRaisesMessage(TypeError, msg):
with request_context.bind_template(Template("")):
pass
def test_context_copyable(self):
request_context = RequestContext(HttpRequest())
request_context_copy = copy(request_context)
self.assertIsInstance(request_context_copy, RequestContext)
self.assertEqual(request_context_copy.dicts, request_context.dicts)
self.assertIsNot(request_context_copy.dicts, request_context.dicts)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/utils.py | tests/template_tests/utils.py | import os
from functools import wraps
from django.template.engine import Engine
from django.test.utils import override_settings
from django.utils.safestring import mark_safe
ROOT = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_DIR = os.path.join(ROOT, "templates")
def setup(templates, *args, test_once=False, debug_only=False):
"""
Runs test method multiple times in the following order:
debug cached string_if_invalid
----- ------ -----------------
False False
False True
False False INVALID
False True INVALID
True False
True True
Use test_once=True to test deprecation warnings since the message won't be
displayed multiple times.
"""
for arg in args:
templates.update(arg)
# numerous tests make use of an inclusion tag
# add this in here for simplicity
templates["inclusion.html"] = "{{ result }}"
loaders = [
(
"django.template.loaders.cached.Loader",
[
("django.template.loaders.locmem.Loader", templates),
],
),
]
def decorator(func):
# Make Engine.get_default() raise an exception to ensure that tests
# are properly isolated from Django's global settings.
@override_settings(TEMPLATES=None)
@wraps(func)
def inner(self):
# Set up custom template tag libraries if specified
libraries = getattr(self, "libraries", {})
self.engine = Engine(
libraries=libraries,
loaders=loaders,
debug=debug_only,
)
func(self)
if test_once:
return
func(self)
if debug_only:
return
self.engine = Engine(
libraries=libraries,
loaders=loaders,
string_if_invalid="INVALID",
)
func(self)
func(self)
self.engine = Engine(
debug=True,
libraries=libraries,
loaders=loaders,
)
func(self)
func(self)
return inner
return decorator
# Helper objects
class SomeException(Exception):
silent_variable_failure = True
class SomeOtherException(Exception):
pass
class ShouldNotExecuteException(Exception):
pass
class SomeClass:
def __init__(self):
self.otherclass = OtherClass()
def method(self):
return "SomeClass.method"
def method2(self, o):
return o
def method3(self):
raise SomeException
def method4(self):
raise SomeOtherException
def method5(self):
raise TypeError
def __getitem__(self, key):
if key == "silent_fail_key":
raise SomeException
elif key == "noisy_fail_key":
raise SomeOtherException
raise KeyError
@property
def silent_fail_attribute(self):
raise SomeException
@property
def noisy_fail_attribute(self):
raise SomeOtherException
@property
def attribute_error_attribute(self):
raise AttributeError
@property
def type_error_attribute(self):
raise TypeError
class OtherClass:
def method(self):
return "OtherClass.method"
class TestObj:
def is_true(self):
return True
def is_false(self):
return False
def is_bad(self):
raise ShouldNotExecuteException()
class SilentGetItemClass:
def __getitem__(self, key):
raise SomeException
class SilentAttrClass:
def b(self):
raise SomeException
b = property(b)
class UTF8Class:
"Class whose __str__ returns non-ASCII data"
def __str__(self):
return "ŠĐĆŽćžšđ"
# These two classes are used to test auto-escaping of string output.
class UnsafeClass:
def __str__(self):
return "you & me"
class SafeClass:
def __str__(self):
return mark_safe("you > me")
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/alternate_urls.py | tests/template_tests/alternate_urls.py | from django.urls import path
from . import views
urlpatterns = [
# View returning a template response
path("template_response_view/", views.template_response_view),
# A view that can be hard to find...
path("snark/", views.snark, name="snark"),
]
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_callables.py | tests/template_tests/test_callables.py | from unittest import TestCase
from django.db.models.utils import AltersData
from django.template import Context, Engine
class CallableVariablesTests(TestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine()
super().setUpClass()
def test_callable(self):
class Doodad:
def __init__(self, value):
self.num_calls = 0
self.value = value
def __call__(self):
self.num_calls += 1
return {"the_value": self.value}
my_doodad = Doodad(42)
c = Context({"my_doodad": my_doodad})
# We can't access ``my_doodad.value`` in the template, because
# ``my_doodad.__call__`` will be invoked first, yielding a dictionary
# without a key ``value``.
t = self.engine.from_string("{{ my_doodad.value }}")
self.assertEqual(t.render(c), "")
# We can confirm that the doodad has been called
self.assertEqual(my_doodad.num_calls, 1)
# But we can access keys on the dict that's returned
# by ``__call__``, instead.
t = self.engine.from_string("{{ my_doodad.the_value }}")
self.assertEqual(t.render(c), "42")
self.assertEqual(my_doodad.num_calls, 2)
def test_alters_data(self):
class Doodad:
alters_data = True
def __init__(self, value):
self.num_calls = 0
self.value = value
def __call__(self):
self.num_calls += 1
return {"the_value": self.value}
my_doodad = Doodad(42)
c = Context({"my_doodad": my_doodad})
# Since ``my_doodad.alters_data`` is True, the template system will not
# try to call our doodad but will use string_if_invalid
t = self.engine.from_string("{{ my_doodad.value }}")
self.assertEqual(t.render(c), "")
t = self.engine.from_string("{{ my_doodad.the_value }}")
self.assertEqual(t.render(c), "")
# Double-check that the object was really never called during the
# template rendering.
self.assertEqual(my_doodad.num_calls, 0)
def test_alters_data_propagation(self):
class GrandParentLeft(AltersData):
def my_method(self):
return 42
my_method.alters_data = True
class ParentLeft(GrandParentLeft):
def change_alters_data_method(self):
return 63
change_alters_data_method.alters_data = True
def sub_non_callable_method(self):
return 64
sub_non_callable_method.alters_data = True
class ParentRight(AltersData):
def other_method(self):
return 52
other_method.alters_data = True
class Child(ParentLeft, ParentRight):
def my_method(self):
return 101
def other_method(self):
return 102
def change_alters_data_method(self):
return 103
change_alters_data_method.alters_data = False
sub_non_callable_method = 104
class GrandChild(Child):
pass
child = Child()
self.assertIs(child.my_method.alters_data, True)
self.assertIs(child.other_method.alters_data, True)
self.assertIs(child.change_alters_data_method.alters_data, False)
grand_child = GrandChild()
self.assertIs(grand_child.my_method.alters_data, True)
self.assertIs(grand_child.other_method.alters_data, True)
self.assertIs(grand_child.change_alters_data_method.alters_data, False)
c = Context({"element": grand_child})
t = self.engine.from_string("{{ element.my_method }}")
self.assertEqual(t.render(c), "")
t = self.engine.from_string("{{ element.other_method }}")
self.assertEqual(t.render(c), "")
t = self.engine.from_string("{{ element.change_alters_data_method }}")
self.assertEqual(t.render(c), "103")
t = self.engine.from_string("{{ element.sub_non_callable_method }}")
self.assertEqual(t.render(c), "104")
def test_do_not_call(self):
class Doodad:
do_not_call_in_templates = True
def __init__(self, value):
self.num_calls = 0
self.value = value
def __call__(self):
self.num_calls += 1
return {"the_value": self.value}
my_doodad = Doodad(42)
c = Context({"my_doodad": my_doodad})
# Since ``my_doodad.do_not_call_in_templates`` is True, the template
# system will not try to call our doodad. We can access its attributes
# as normal, and we don't have access to the dict that it returns when
# called.
t = self.engine.from_string("{{ my_doodad.value }}")
self.assertEqual(t.render(c), "42")
t = self.engine.from_string("{{ my_doodad.the_value }}")
self.assertEqual(t.render(c), "")
# Double-check that the object was really never called during the
# template rendering.
self.assertEqual(my_doodad.num_calls, 0)
def test_do_not_call_and_alters_data(self):
# If we combine ``alters_data`` and ``do_not_call_in_templates``, the
# ``alters_data`` attribute will not make any difference in the
# template system's behavior.
class Doodad:
do_not_call_in_templates = True
alters_data = True
def __init__(self, value):
self.num_calls = 0
self.value = value
def __call__(self):
self.num_calls += 1
return {"the_value": self.value}
my_doodad = Doodad(42)
c = Context({"my_doodad": my_doodad})
t = self.engine.from_string("{{ my_doodad.value }}")
self.assertEqual(t.render(c), "42")
t = self.engine.from_string("{{ my_doodad.the_value }}")
self.assertEqual(t.render(c), "")
# Double-check that the object was really never called during the
# template rendering.
self.assertEqual(my_doodad.num_calls, 0)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_response.py | tests/template_tests/test_response.py | import pickle
import time
from datetime import datetime
from django.template import engines
from django.template.response import (
ContentNotRenderedError,
SimpleTemplateResponse,
TemplateResponse,
)
from django.test import (
RequestFactory,
SimpleTestCase,
modify_settings,
override_settings,
)
from django.test.utils import require_jinja2
from .utils import TEMPLATE_DIR
def test_processor(request):
return {"processors": "yes"}
test_processor_name = "template_tests.test_response.test_processor"
# A test middleware that installs a temporary URLConf
def custom_urlconf_middleware(get_response):
def middleware(request):
request.urlconf = "template_tests.alternate_urls"
return get_response(request)
return middleware
class SimpleTemplateResponseTest(SimpleTestCase):
def _response(self, template="foo", *args, **kwargs):
template = engines["django"].from_string(template)
return SimpleTemplateResponse(template, *args, **kwargs)
def test_template_resolving(self):
response = SimpleTemplateResponse("first/test.html")
response.render()
self.assertEqual(response.content, b"First template\n")
templates = ["foo.html", "second/test.html", "first/test.html"]
response = SimpleTemplateResponse(templates)
response.render()
self.assertEqual(response.content, b"Second template\n")
response = self._response()
response.render()
self.assertEqual(response.content, b"foo")
def test_explicit_baking(self):
# explicit baking
response = self._response()
self.assertFalse(response.is_rendered)
response.render()
self.assertTrue(response.is_rendered)
def test_render(self):
# response is not re-rendered without the render call
response = self._response().render()
self.assertEqual(response.content, b"foo")
# rebaking doesn't change the rendered content
template = engines["django"].from_string("bar{{ baz }}")
response.template_name = template
response.render()
self.assertEqual(response.content, b"foo")
# but rendered content can be overridden by manually
# setting content
response.content = "bar"
self.assertEqual(response.content, b"bar")
def test_iteration_unrendered(self):
# unrendered response raises an exception on iteration
response = self._response()
self.assertFalse(response.is_rendered)
def iteration():
list(response)
msg = "The response content must be rendered before it can be iterated over."
with self.assertRaisesMessage(ContentNotRenderedError, msg):
iteration()
self.assertFalse(response.is_rendered)
def test_iteration_rendered(self):
# iteration works for rendered responses
response = self._response().render()
self.assertEqual(list(response), [b"foo"])
def test_content_access_unrendered(self):
# unrendered response raises an exception when content is accessed
response = self._response()
self.assertFalse(response.is_rendered)
with self.assertRaises(ContentNotRenderedError):
response.content
self.assertFalse(response.is_rendered)
def test_content_access_rendered(self):
# rendered response content can be accessed
response = self._response().render()
self.assertEqual(response.content, b"foo")
def test_set_content(self):
# content can be overridden
response = self._response()
self.assertFalse(response.is_rendered)
response.content = "spam"
self.assertTrue(response.is_rendered)
self.assertEqual(response.content, b"spam")
response.content = "baz"
self.assertEqual(response.content, b"baz")
def test_dict_context(self):
response = self._response("{{ foo }}{{ processors }}", {"foo": "bar"})
self.assertEqual(response.context_data, {"foo": "bar"})
response.render()
self.assertEqual(response.content, b"bar")
def test_kwargs(self):
response = self._response(
content_type="application/json", status=504, charset="ascii"
)
self.assertEqual(response.headers["content-type"], "application/json")
self.assertEqual(response.status_code, 504)
self.assertEqual(response.charset, "ascii")
def test_args(self):
response = SimpleTemplateResponse("", {}, "application/json", 504)
self.assertEqual(response.headers["content-type"], "application/json")
self.assertEqual(response.status_code, 504)
@require_jinja2
def test_using(self):
response = SimpleTemplateResponse("template_tests/using.html").render()
self.assertEqual(response.content, b"DTL\n")
response = SimpleTemplateResponse(
"template_tests/using.html", using="django"
).render()
self.assertEqual(response.content, b"DTL\n")
response = SimpleTemplateResponse(
"template_tests/using.html", using="jinja2"
).render()
self.assertEqual(response.content, b"Jinja2\n")
def test_post_callbacks(self):
"Rendering a template response triggers the post-render callbacks"
post = []
def post1(obj):
post.append("post1")
def post2(obj):
post.append("post2")
response = SimpleTemplateResponse("first/test.html", {})
response.add_post_render_callback(post1)
response.add_post_render_callback(post2)
# When the content is rendered, all the callbacks are invoked, too.
response.render()
self.assertEqual(response.content, b"First template\n")
self.assertEqual(post, ["post1", "post2"])
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = SimpleTemplateResponse(
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
with self.assertRaises(ContentNotRenderedError):
pickle.dumps(response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(
unpickled_response.headers["content-type"], response.headers["content-type"]
)
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled response doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = ("template_name", "context_data", "_post_render_callbacks")
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def test_repickling(self):
response = SimpleTemplateResponse(
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
with self.assertRaises(ContentNotRenderedError):
pickle.dumps(response)
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
pickle.dumps(unpickled_response)
def test_pickling_cookie(self):
response = SimpleTemplateResponse(
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
response.cookies["key"] = "value"
response.render()
pickled_response = pickle.dumps(response, pickle.HIGHEST_PROTOCOL)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.cookies["key"].value, "value")
def test_headers(self):
response = SimpleTemplateResponse(
"first/test.html",
{"value": 123, "fn": datetime.now},
headers={"X-Foo": "foo"},
)
self.assertEqual(response.headers["X-Foo"], "foo")
@override_settings(
TEMPLATES=[
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [TEMPLATE_DIR],
"OPTIONS": {
"context_processors": [test_processor_name],
},
}
]
)
class TemplateResponseTest(SimpleTestCase):
factory = RequestFactory()
def _response(self, template="foo", *args, **kwargs):
self._request = self.factory.get("/")
template = engines["django"].from_string(template)
return TemplateResponse(self._request, template, *args, **kwargs)
def test_render(self):
response = self._response("{{ foo }}{{ processors }}").render()
self.assertEqual(response.content, b"yes")
def test_render_with_requestcontext(self):
response = self._response("{{ foo }}{{ processors }}", {"foo": "bar"}).render()
self.assertEqual(response.content, b"baryes")
def test_context_processor_priority(self):
# context processors should be overridden by passed-in context
response = self._response(
"{{ foo }}{{ processors }}", {"processors": "no"}
).render()
self.assertEqual(response.content, b"no")
def test_kwargs(self):
response = self._response(content_type="application/json", status=504)
self.assertEqual(response.headers["content-type"], "application/json")
self.assertEqual(response.status_code, 504)
def test_args(self):
response = TemplateResponse(
self.factory.get("/"), "", {}, "application/json", 504
)
self.assertEqual(response.headers["content-type"], "application/json")
self.assertEqual(response.status_code, 504)
@require_jinja2
def test_using(self):
request = self.factory.get("/")
response = TemplateResponse(request, "template_tests/using.html").render()
self.assertEqual(response.content, b"DTL\n")
response = TemplateResponse(
request, "template_tests/using.html", using="django"
).render()
self.assertEqual(response.content, b"DTL\n")
response = TemplateResponse(
request, "template_tests/using.html", using="jinja2"
).render()
self.assertEqual(response.content, b"Jinja2\n")
def test_pickling(self):
# Create a template response. The context is
# known to be unpicklable (e.g., a function).
response = TemplateResponse(
self.factory.get("/"),
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
with self.assertRaises(ContentNotRenderedError):
pickle.dumps(response)
# But if we render the response, we can pickle it.
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
self.assertEqual(unpickled_response.content, response.content)
self.assertEqual(
unpickled_response.headers["content-type"], response.headers["content-type"]
)
self.assertEqual(unpickled_response.status_code, response.status_code)
# ...and the unpickled response doesn't have the
# template-related attributes, so it can't be re-rendered
template_attrs = (
"template_name",
"context_data",
"_post_render_callbacks",
"_request",
)
for attr in template_attrs:
self.assertFalse(hasattr(unpickled_response, attr))
# ...and requesting any of those attributes raises an exception
for attr in template_attrs:
with self.assertRaises(AttributeError):
getattr(unpickled_response, attr)
def test_repickling(self):
response = SimpleTemplateResponse(
"first/test.html",
{
"value": 123,
"fn": datetime.now,
},
)
with self.assertRaises(ContentNotRenderedError):
pickle.dumps(response)
response.render()
pickled_response = pickle.dumps(response)
unpickled_response = pickle.loads(pickled_response)
pickle.dumps(unpickled_response)
def test_headers(self):
response = TemplateResponse(
self.factory.get("/"),
"first/test.html",
{"value": 123, "fn": datetime.now},
headers={"X-Foo": "foo"},
)
self.assertEqual(response.headers["X-Foo"], "foo")
@modify_settings(
MIDDLEWARE={"append": ["template_tests.test_response.custom_urlconf_middleware"]}
)
@override_settings(ROOT_URLCONF="template_tests.urls")
class CustomURLConfTest(SimpleTestCase):
def test_custom_urlconf(self):
response = self.client.get("/template_response_view/")
self.assertContains(response, "This is where you can find the snark: /snark/")
@modify_settings(
MIDDLEWARE={
"append": [
"django.middleware.cache.FetchFromCacheMiddleware",
"django.middleware.cache.UpdateCacheMiddleware",
],
},
)
@override_settings(
CACHE_MIDDLEWARE_SECONDS=2, ROOT_URLCONF="template_tests.alternate_urls"
)
class CacheMiddlewareTest(SimpleTestCase):
def test_middleware_caching(self):
response = self.client.get("/template_response_view/")
self.assertEqual(response.status_code, 200)
time.sleep(1.0)
response2 = self.client.get("/template_response_view/")
self.assertEqual(response2.status_code, 200)
self.assertEqual(response.content, response2.content)
time.sleep(2.0)
# Let the cache expire and test again
response2 = self.client.get("/template_response_view/")
self.assertEqual(response2.status_code, 200)
self.assertNotEqual(response.content, response2.content)
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/test_loaders.py | tests/template_tests/test_loaders.py | import os.path
import sys
import tempfile
import unittest
from contextlib import contextmanager
from django.template import TemplateDoesNotExist
from django.template.engine import Engine
from django.test import SimpleTestCase, override_settings
from django.utils.functional import lazystr
from .utils import TEMPLATE_DIR
class CachedLoaderTests(SimpleTestCase):
def setUp(self):
self.engine = Engine(
dirs=[TEMPLATE_DIR],
loaders=[
(
"django.template.loaders.cached.Loader",
[
"django.template.loaders.filesystem.Loader",
],
),
],
)
def test_get_template(self):
template = self.engine.get_template("index.html")
self.assertEqual(template.origin.name, os.path.join(TEMPLATE_DIR, "index.html"))
self.assertEqual(template.origin.template_name, "index.html")
self.assertEqual(
template.origin.loader, self.engine.template_loaders[0].loaders[0]
)
cache = self.engine.template_loaders[0].get_template_cache
self.assertEqual(cache["index.html"], template)
# Run a second time from cache
template = self.engine.get_template("index.html")
self.assertEqual(template.origin.name, os.path.join(TEMPLATE_DIR, "index.html"))
self.assertEqual(template.origin.template_name, "index.html")
self.assertEqual(
template.origin.loader, self.engine.template_loaders[0].loaders[0]
)
def test_get_template_missing_debug_off(self):
"""
With template debugging disabled, the raw TemplateDoesNotExist class
should be cached when a template is missing. See ticket #26306 and
docstrings in the cached loader for details.
"""
self.engine.debug = False
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("prod-template-missing.html")
e = self.engine.template_loaders[0].get_template_cache[
"prod-template-missing.html"
]
self.assertEqual(e, TemplateDoesNotExist)
def test_get_template_missing_debug_on(self):
"""
With template debugging enabled, a TemplateDoesNotExist instance
should be cached when a template is missing.
"""
self.engine.debug = True
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("debug-template-missing.html")
e = self.engine.template_loaders[0].get_template_cache[
"debug-template-missing.html"
]
self.assertIsInstance(e, TemplateDoesNotExist)
self.assertEqual(e.args[0], "debug-template-missing.html")
def test_cached_exception_no_traceback(self):
"""
When a TemplateDoesNotExist instance is cached, the cached instance
should not contain the __traceback__, __context__, or __cause__
attributes that Python sets when raising exceptions.
"""
self.engine.debug = True
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("no-traceback-in-cache.html")
e = self.engine.template_loaders[0].get_template_cache[
"no-traceback-in-cache.html"
]
error_msg = "Cached TemplateDoesNotExist must not have been thrown."
self.assertIsNone(e.__traceback__, error_msg)
self.assertIsNone(e.__context__, error_msg)
self.assertIsNone(e.__cause__, error_msg)
def test_template_name_leading_dash_caching(self):
"""
#26536 -- A leading dash in a template name shouldn't be stripped
from its cache key.
"""
self.assertEqual(
self.engine.template_loaders[0].cache_key("-template.html", []),
"-template.html",
)
def test_template_name_lazy_string(self):
"""
#26603 -- A template name specified as a lazy string should be forced
to text before computing its cache key.
"""
self.assertEqual(
self.engine.template_loaders[0].cache_key(lazystr("template.html"), []),
"template.html",
)
def test_get_dirs(self):
inner_dirs = self.engine.template_loaders[0].loaders[0].get_dirs()
self.assertSequenceEqual(
list(self.engine.template_loaders[0].get_dirs()), list(inner_dirs)
)
class FileSystemLoaderTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine(
dirs=[TEMPLATE_DIR], loaders=["django.template.loaders.filesystem.Loader"]
)
super().setUpClass()
@contextmanager
def set_dirs(self, dirs):
original_dirs = self.engine.dirs
self.engine.dirs = dirs
try:
yield
finally:
self.engine.dirs = original_dirs
@contextmanager
def source_checker(self, dirs):
loader = self.engine.template_loaders[0]
def check_sources(path, expected_sources):
expected_sources = [os.path.abspath(s) for s in expected_sources]
self.assertEqual(
[origin.name for origin in loader.get_template_sources(path)],
expected_sources,
)
with self.set_dirs(dirs):
yield check_sources
def test_get_template(self):
template = self.engine.get_template("index.html")
self.assertEqual(template.origin.name, os.path.join(TEMPLATE_DIR, "index.html"))
self.assertEqual(template.origin.template_name, "index.html")
self.assertEqual(template.origin.loader, self.engine.template_loaders[0])
self.assertEqual(
template.origin.loader_name, "django.template.loaders.filesystem.Loader"
)
def test_loaders_dirs(self):
engine = Engine(
loaders=[("django.template.loaders.filesystem.Loader", [TEMPLATE_DIR])]
)
template = engine.get_template("index.html")
self.assertEqual(template.origin.name, os.path.join(TEMPLATE_DIR, "index.html"))
def test_loaders_dirs_empty(self):
"""An empty dirs list in loaders overrides top level dirs."""
engine = Engine(
dirs=[TEMPLATE_DIR],
loaders=[("django.template.loaders.filesystem.Loader", [])],
)
with self.assertRaises(TemplateDoesNotExist):
engine.get_template("index.html")
def test_directory_security(self):
with self.source_checker(["/dir1", "/dir2"]) as check_sources:
check_sources("index.html", ["/dir1/index.html", "/dir2/index.html"])
check_sources("/etc/passwd", [])
check_sources("etc/passwd", ["/dir1/etc/passwd", "/dir2/etc/passwd"])
check_sources("../etc/passwd", [])
check_sources("../../../etc/passwd", [])
check_sources("/dir1/index.html", ["/dir1/index.html"])
check_sources("../dir2/index.html", ["/dir2/index.html"])
check_sources("/dir1blah", [])
check_sources("../dir1blah", [])
def test_unicode_template_name(self):
with self.source_checker(["/dir1", "/dir2"]) as check_sources:
check_sources("Ångström", ["/dir1/Ångström", "/dir2/Ångström"])
def test_bytestring(self):
loader = self.engine.template_loaders[0]
msg = "Can't mix strings and bytes in path components"
with self.assertRaisesMessage(TypeError, msg):
list(loader.get_template_sources(b"\xc3\x85ngstr\xc3\xb6m"))
def test_unicode_dir_name(self):
with self.source_checker(["/Straße"]) as check_sources:
check_sources("Ångström", ["/Straße/Ångström"])
@unittest.skipUnless(
os.path.normcase("/TEST") == os.path.normpath("/test"),
"This test only runs on case-sensitive file systems.",
)
def test_case_sensitivity(self):
with self.source_checker(["/dir1", "/DIR2"]) as check_sources:
check_sources("index.html", ["/dir1/index.html", "/DIR2/index.html"])
check_sources("/DIR1/index.HTML", ["/DIR1/index.HTML"])
def test_file_does_not_exist(self):
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("doesnotexist.html")
@unittest.skipIf(
sys.platform == "win32",
"Python on Windows doesn't have working os.chmod().",
)
def test_permissions_error(self):
with tempfile.NamedTemporaryFile() as tmpfile:
tmpdir = os.path.dirname(tmpfile.name)
tmppath = os.path.join(tmpdir, tmpfile.name)
os.chmod(tmppath, 0o0222)
with self.set_dirs([tmpdir]):
with self.assertRaisesMessage(PermissionError, "Permission denied"):
self.engine.get_template(tmpfile.name)
def test_notafile_error(self):
# Windows raises PermissionError when trying to open a directory.
with self.assertRaises(
PermissionError if sys.platform == "win32" else IsADirectoryError
):
self.engine.get_template("first")
class AppDirectoriesLoaderTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine(
loaders=["django.template.loaders.app_directories.Loader"],
)
super().setUpClass()
@override_settings(INSTALLED_APPS=["template_tests"])
def test_get_template(self):
template = self.engine.get_template("index.html")
self.assertEqual(template.origin.name, os.path.join(TEMPLATE_DIR, "index.html"))
self.assertEqual(template.origin.template_name, "index.html")
self.assertEqual(template.origin.loader, self.engine.template_loaders[0])
@override_settings(INSTALLED_APPS=[])
def test_not_installed(self):
with self.assertRaises(TemplateDoesNotExist):
self.engine.get_template("index.html")
class LocmemLoaderTests(SimpleTestCase):
@classmethod
def setUpClass(cls):
cls.engine = Engine(
loaders=[
(
"django.template.loaders.locmem.Loader",
{
"index.html": "index",
},
)
],
)
super().setUpClass()
def test_get_template(self):
template = self.engine.get_template("index.html")
self.assertEqual(template.origin.name, "index.html")
self.assertEqual(template.origin.template_name, "index.html")
self.assertEqual(template.origin.loader, self.engine.template_loaders[0])
| python | BSD-3-Clause | 3201a895cba335000827b28768a7b7105c81b415 | 2026-01-04T14:38:15.489092Z | false |
django/django | https://github.com/django/django/blob/3201a895cba335000827b28768a7b7105c81b415/tests/template_tests/__init__.py | tests/template_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/template_tests/broken_tag.py | tests/template_tests/broken_tag.py | from django import Xtemplate # NOQA
| 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.