hash
stringlengths
64
64
content
stringlengths
0
1.51M
d93f05b0c04129e8f17dd3dad20fbd3b3928a4c02ff81a8c29f7d078aed58c30
from django.test import SimpleTestCase from django.utils.topological_sort import ( CyclicDependencyError, stable_topological_sort, topological_sort_as_sets, ) class TopologicalSortTests(SimpleTestCase): def test_basic(self): dependency_graph = { 1: {2, 3}, 2: set(), 3: set(), 4: {5, 6}, 5: set(), 6: {5}, } self.assertEqual( list(topological_sort_as_sets(dependency_graph)), [{2, 3, 5}, {1, 6}, {4}] ) self.assertEqual( stable_topological_sort([1, 2, 3, 4, 5, 6], dependency_graph), [2, 3, 5, 1, 6, 4], ) def test_cyclic_dependency(self): msg = "Cyclic dependency in graph: (1, {2}), (2, {1})" with self.assertRaisesMessage(CyclicDependencyError, msg): list(topological_sort_as_sets({1: {2}, 2: {1}}))
3426aa3be97335e89d19a7564020e54ce418e9ddac649df414d190e99486d85f
from unittest import mock from django.conf import settings from django.db import connection, models from django.db.models.functions import Lower, Upper from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature from django.test.utils import isolate_apps from .models import Book, ChildModel1, ChildModel2 class SimpleIndexesTests(SimpleTestCase): def test_suffix(self): self.assertEqual(models.Index.suffix, "idx") def test_repr(self): index = models.Index(fields=["title"]) named_index = models.Index(fields=["title"], name="title_idx") multi_col_index = models.Index(fields=["title", "author"]) partial_index = models.Index( fields=["title"], name="long_books_idx", condition=models.Q(pages__gt=400) ) covering_index = models.Index( fields=["title"], name="include_idx", include=["author", "pages"], ) opclasses_index = models.Index( fields=["headline", "body"], name="opclasses_idx", opclasses=["varchar_pattern_ops", "text_pattern_ops"], ) func_index = models.Index(Lower("title"), "subtitle", name="book_func_idx") tablespace_index = models.Index( fields=["title"], db_tablespace="idx_tbls", name="book_tablespace_idx", ) self.assertEqual(repr(index), "<Index: fields=['title']>") self.assertEqual( repr(named_index), "<Index: fields=['title'] name='title_idx'>", ) self.assertEqual(repr(multi_col_index), "<Index: fields=['title', 'author']>") self.assertEqual( repr(partial_index), "<Index: fields=['title'] name='long_books_idx' " "condition=(AND: ('pages__gt', 400))>", ) self.assertEqual( repr(covering_index), "<Index: fields=['title'] name='include_idx' " "include=('author', 'pages')>", ) self.assertEqual( repr(opclasses_index), "<Index: fields=['headline', 'body'] name='opclasses_idx' " "opclasses=['varchar_pattern_ops', 'text_pattern_ops']>", ) self.assertEqual( repr(func_index), "<Index: expressions=(Lower(F(title)), F(subtitle)) " "name='book_func_idx'>", ) self.assertEqual( repr(tablespace_index), "<Index: fields=['title'] name='book_tablespace_idx' " "db_tablespace='idx_tbls'>", ) def test_eq(self): index = models.Index(fields=["title"]) same_index = models.Index(fields=["title"]) another_index = models.Index(fields=["title", "author"]) index.model = Book same_index.model = Book another_index.model = Book self.assertEqual(index, same_index) self.assertEqual(index, mock.ANY) self.assertNotEqual(index, another_index) def test_eq_func(self): index = models.Index(Lower("title"), models.F("author"), name="book_func_idx") same_index = models.Index(Lower("title"), "author", name="book_func_idx") another_index = models.Index(Lower("title"), name="book_func_idx") self.assertEqual(index, same_index) self.assertEqual(index, mock.ANY) self.assertNotEqual(index, another_index) def test_index_fields_type(self): with self.assertRaisesMessage( ValueError, "Index.fields must be a list or tuple." ): models.Index(fields="title") def test_index_fields_strings(self): msg = "Index.fields must contain only strings with field names." with self.assertRaisesMessage(ValueError, msg): models.Index(fields=[models.F("title")]) def test_fields_tuple(self): self.assertEqual(models.Index(fields=("title",)).fields, ["title"]) def test_requires_field_or_expression(self): msg = "At least one field or expression is required to define an index." with self.assertRaisesMessage(ValueError, msg): models.Index() def test_expressions_and_fields_mutually_exclusive(self): msg = "Index.fields and expressions are mutually exclusive." with self.assertRaisesMessage(ValueError, msg): models.Index(Upper("foo"), fields=["field"]) def test_opclasses_requires_index_name(self): with self.assertRaisesMessage( ValueError, "An index must be named to use opclasses." ): models.Index(opclasses=["jsonb_path_ops"]) def test_opclasses_requires_list_or_tuple(self): with self.assertRaisesMessage( ValueError, "Index.opclasses must be a list or tuple." ): models.Index( name="test_opclass", fields=["field"], opclasses="jsonb_path_ops" ) def test_opclasses_and_fields_same_length(self): msg = "Index.fields and Index.opclasses must have the same number of elements." with self.assertRaisesMessage(ValueError, msg): models.Index( name="test_opclass", fields=["field", "other"], opclasses=["jsonb_path_ops"], ) def test_condition_requires_index_name(self): with self.assertRaisesMessage( ValueError, "An index must be named to use condition." ): models.Index(condition=models.Q(pages__gt=400)) def test_expressions_requires_index_name(self): msg = "An index must be named to use expressions." with self.assertRaisesMessage(ValueError, msg): models.Index(Lower("field")) def test_expressions_with_opclasses(self): msg = ( "Index.opclasses cannot be used with expressions. Use " "django.contrib.postgres.indexes.OpClass() instead." ) with self.assertRaisesMessage(ValueError, msg): models.Index( Lower("field"), name="test_func_opclass", opclasses=["jsonb_path_ops"], ) def test_condition_must_be_q(self): with self.assertRaisesMessage( ValueError, "Index.condition must be a Q instance." ): models.Index(condition="invalid", name="long_book_idx") def test_include_requires_list_or_tuple(self): msg = "Index.include must be a list or tuple." with self.assertRaisesMessage(ValueError, msg): models.Index(name="test_include", fields=["field"], include="other") def test_include_requires_index_name(self): msg = "A covering index must be named." with self.assertRaisesMessage(ValueError, msg): models.Index(fields=["field"], include=["other"]) def test_name_auto_generation(self): index = models.Index(fields=["author"]) index.set_name_with_model(Book) self.assertEqual(index.name, "model_index_author_0f5565_idx") # '-' for DESC columns should be accounted for in the index name. index = models.Index(fields=["-author"]) index.set_name_with_model(Book) self.assertEqual(index.name, "model_index_author_708765_idx") # fields may be truncated in the name. db_column is used for naming. long_field_index = models.Index(fields=["pages"]) long_field_index.set_name_with_model(Book) self.assertEqual(long_field_index.name, "model_index_page_co_69235a_idx") # suffix can't be longer than 3 characters. long_field_index.suffix = "suff" msg = ( "Index too long for multiple database support. Is self.suffix " "longer than 3 characters?" ) with self.assertRaisesMessage(ValueError, msg): long_field_index.set_name_with_model(Book) @isolate_apps("model_indexes") def test_name_auto_generation_with_quoted_db_table(self): class QuotedDbTable(models.Model): name = models.CharField(max_length=50) class Meta: db_table = '"t_quoted"' index = models.Index(fields=["name"]) index.set_name_with_model(QuotedDbTable) self.assertEqual(index.name, "t_quoted_name_e4ed1b_idx") def test_deconstruction(self): index = models.Index(fields=["title"], db_tablespace="idx_tbls") index.set_name_with_model(Book) path, args, kwargs = index.deconstruct() self.assertEqual(path, "django.db.models.Index") self.assertEqual(args, ()) self.assertEqual( kwargs, { "fields": ["title"], "name": "model_index_title_196f42_idx", "db_tablespace": "idx_tbls", }, ) def test_deconstruct_with_condition(self): index = models.Index( name="big_book_index", fields=["title"], condition=models.Q(pages__gt=400), ) index.set_name_with_model(Book) path, args, kwargs = index.deconstruct() self.assertEqual(path, "django.db.models.Index") self.assertEqual(args, ()) self.assertEqual( kwargs, { "fields": ["title"], "name": "model_index_title_196f42_idx", "condition": models.Q(pages__gt=400), }, ) def test_deconstruct_with_include(self): index = models.Index( name="book_include_idx", fields=["title"], include=["author"], ) index.set_name_with_model(Book) path, args, kwargs = index.deconstruct() self.assertEqual(path, "django.db.models.Index") self.assertEqual(args, ()) self.assertEqual( kwargs, { "fields": ["title"], "name": "model_index_title_196f42_idx", "include": ("author",), }, ) def test_deconstruct_with_expressions(self): index = models.Index(Upper("title"), name="book_func_idx") path, args, kwargs = index.deconstruct() self.assertEqual(path, "django.db.models.Index") self.assertEqual(args, (Upper("title"),)) self.assertEqual(kwargs, {"name": "book_func_idx"}) def test_clone(self): index = models.Index(fields=["title"]) new_index = index.clone() self.assertIsNot(index, new_index) self.assertEqual(index.fields, new_index.fields) def test_clone_with_expressions(self): index = models.Index(Upper("title"), name="book_func_idx") new_index = index.clone() self.assertIsNot(index, new_index) self.assertEqual(index.expressions, new_index.expressions) def test_name_set(self): index_names = [index.name for index in Book._meta.indexes] self.assertCountEqual( index_names, [ "model_index_title_196f42_idx", "model_index_isbn_34f975_idx", "model_indexes_book_barcode_idx", ], ) def test_abstract_children(self): index_names = [index.name for index in ChildModel1._meta.indexes] self.assertEqual( index_names, ["model_index_name_440998_idx", "model_indexes_childmodel1_idx"], ) index_names = [index.name for index in ChildModel2._meta.indexes] self.assertEqual( index_names, ["model_index_name_b6c374_idx", "model_indexes_childmodel2_idx"], ) class IndexesTests(TestCase): @skipUnlessDBFeature("supports_tablespaces") def test_db_tablespace(self): editor = connection.schema_editor() # Index with db_tablespace attribute. for fields in [ # Field with db_tablespace specified on model. ["shortcut"], # Field without db_tablespace specified on model. ["author"], # Multi-column with db_tablespaces specified on model. ["shortcut", "isbn"], # Multi-column without db_tablespace specified on model. ["title", "author"], ]: with self.subTest(fields=fields): index = models.Index(fields=fields, db_tablespace="idx_tbls2") self.assertIn( '"idx_tbls2"', str(index.create_sql(Book, editor)).lower() ) # Indexes without db_tablespace attribute. for fields in [["author"], ["shortcut", "isbn"], ["title", "author"]]: with self.subTest(fields=fields): index = models.Index(fields=fields) # The DEFAULT_INDEX_TABLESPACE setting can't be tested because # it's evaluated when the model class is defined. As a # consequence, @override_settings doesn't work. if settings.DEFAULT_INDEX_TABLESPACE: self.assertIn( '"%s"' % settings.DEFAULT_INDEX_TABLESPACE, str(index.create_sql(Book, editor)).lower(), ) else: self.assertNotIn("TABLESPACE", str(index.create_sql(Book, editor))) # Field with db_tablespace specified on the model and an index without # db_tablespace. index = models.Index(fields=["shortcut"]) self.assertIn('"idx_tbls"', str(index.create_sql(Book, editor)).lower()) @skipUnlessDBFeature("supports_tablespaces") def test_func_with_tablespace(self): # Functional index with db_tablespace attribute. index = models.Index( Lower("shortcut").desc(), name="functional_tbls", db_tablespace="idx_tbls2", ) with connection.schema_editor() as editor: sql = str(index.create_sql(Book, editor)) self.assertIn(editor.quote_name("idx_tbls2"), sql) # Functional index without db_tablespace attribute. index = models.Index(Lower("shortcut").desc(), name="functional_no_tbls") with connection.schema_editor() as editor: sql = str(index.create_sql(Book, editor)) # The DEFAULT_INDEX_TABLESPACE setting can't be tested because it's # evaluated when the model class is defined. As a consequence, # @override_settings doesn't work. if settings.DEFAULT_INDEX_TABLESPACE: self.assertIn( editor.quote_name(settings.DEFAULT_INDEX_TABLESPACE), sql, ) else: self.assertNotIn("TABLESPACE", sql)
e4fce1174b7ee10cd79627924ea634f3fae29fd26ab983b2ac20cacaa898656c
from django.db import models class Book(models.Model): title = models.CharField(max_length=50) author = models.CharField(max_length=50) pages = models.IntegerField(db_column="page_count") shortcut = models.CharField(max_length=50, db_tablespace="idx_tbls") isbn = models.CharField(max_length=50, db_tablespace="idx_tbls") barcode = models.CharField(max_length=31) class Meta: indexes = [ models.Index(fields=["title"]), models.Index(fields=["isbn", "id"]), models.Index( fields=["barcode"], name="%(app_label)s_%(class)s_barcode_idx" ), ] class AbstractModel(models.Model): name = models.CharField(max_length=50) shortcut = models.CharField(max_length=3) class Meta: abstract = True indexes = [ models.Index(fields=["name"]), models.Index(fields=["shortcut"], name="%(app_label)s_%(class)s_idx"), ] class ChildModel1(AbstractModel): pass class ChildModel2(AbstractModel): pass
13d5eaa5a68517c17a1be93db7c1219747667feb74ba031768a5ca34c079ae7c
import threading from datetime import datetime, timedelta from unittest import mock from django.core.exceptions import MultipleObjectsReturned, ObjectDoesNotExist from django.db import DEFAULT_DB_ALIAS, DatabaseError, connections, models from django.db.models.manager import BaseManager from django.db.models.query import MAX_GET_RESULTS, EmptyQuerySet from django.test import ( SimpleTestCase, TestCase, TransactionTestCase, skipUnlessDBFeature, ) from django.utils.translation import gettext_lazy from .models import ( Article, ArticleSelectOnSave, ChildPrimaryKeyWithDefault, FeaturedArticle, PrimaryKeyWithDefault, SelfRef, ) class ModelInstanceCreationTests(TestCase): def test_object_is_not_written_to_database_until_save_was_called(self): a = Article( id=None, headline="Parrot programs in Python", pub_date=datetime(2005, 7, 28), ) self.assertIsNone(a.id) self.assertEqual(Article.objects.count(), 0) # Save it into the database. You have to call save() explicitly. a.save() self.assertIsNotNone(a.id) self.assertEqual(Article.objects.count(), 1) def test_can_initialize_model_instance_using_positional_arguments(self): """ You can initialize a model instance using positional arguments, which should match the field order as defined in the model. """ a = Article(None, "Second article", datetime(2005, 7, 29)) a.save() self.assertEqual(a.headline, "Second article") self.assertEqual(a.pub_date, datetime(2005, 7, 29, 0, 0)) def test_can_create_instance_using_kwargs(self): a = Article( id=None, headline="Third article", pub_date=datetime(2005, 7, 30), ) a.save() self.assertEqual(a.headline, "Third article") self.assertEqual(a.pub_date, datetime(2005, 7, 30, 0, 0)) def test_autofields_generate_different_values_for_each_instance(self): a1 = Article.objects.create( headline="First", pub_date=datetime(2005, 7, 30, 0, 0) ) a2 = Article.objects.create( headline="First", pub_date=datetime(2005, 7, 30, 0, 0) ) a3 = Article.objects.create( headline="First", pub_date=datetime(2005, 7, 30, 0, 0) ) self.assertNotEqual(a3.id, a1.id) self.assertNotEqual(a3.id, a2.id) def test_can_mix_and_match_position_and_kwargs(self): # You can also mix and match position and keyword arguments, but # be sure not to duplicate field information. a = Article(None, "Fourth article", pub_date=datetime(2005, 7, 31)) a.save() self.assertEqual(a.headline, "Fourth article") def test_positional_and_keyword_args_for_the_same_field(self): msg = "Article() got both positional and keyword arguments for field '%s'." with self.assertRaisesMessage(TypeError, msg % "headline"): Article(None, "Fifth article", headline="Other headline.") with self.assertRaisesMessage(TypeError, msg % "headline"): Article(None, "Sixth article", headline="") with self.assertRaisesMessage(TypeError, msg % "pub_date"): Article(None, "Seventh article", datetime(2021, 3, 1), pub_date=None) def test_cannot_create_instance_with_invalid_kwargs(self): msg = "Article() got unexpected keyword arguments: 'foo'" with self.assertRaisesMessage(TypeError, msg): Article( id=None, headline="Some headline", pub_date=datetime(2005, 7, 31), foo="bar", ) msg = "Article() got unexpected keyword arguments: 'foo', 'bar'" with self.assertRaisesMessage(TypeError, msg): Article( id=None, headline="Some headline", pub_date=datetime(2005, 7, 31), foo="bar", bar="baz", ) def test_can_leave_off_value_for_autofield_and_it_gets_value_on_save(self): """ You can leave off the value for an AutoField when creating an object, because it'll get filled in automatically when you save(). """ a = Article(headline="Article 5", pub_date=datetime(2005, 7, 31)) a.save() self.assertEqual(a.headline, "Article 5") self.assertIsNotNone(a.id) def test_leaving_off_a_field_with_default_set_the_default_will_be_saved(self): a = Article(pub_date=datetime(2005, 7, 31)) a.save() self.assertEqual(a.headline, "Default headline") def test_for_datetimefields_saves_as_much_precision_as_was_given(self): """as much precision in *seconds*""" a1 = Article( headline="Article 7", pub_date=datetime(2005, 7, 31, 12, 30), ) a1.save() self.assertEqual( Article.objects.get(id__exact=a1.id).pub_date, datetime(2005, 7, 31, 12, 30) ) a2 = Article( headline="Article 8", pub_date=datetime(2005, 7, 31, 12, 30, 45), ) a2.save() self.assertEqual( Article.objects.get(id__exact=a2.id).pub_date, datetime(2005, 7, 31, 12, 30, 45), ) def test_saving_an_object_again_does_not_create_a_new_object(self): a = Article(headline="original", pub_date=datetime(2014, 5, 16)) a.save() current_id = a.id a.save() self.assertEqual(a.id, current_id) a.headline = "Updated headline" a.save() self.assertEqual(a.id, current_id) def test_querysets_checking_for_membership(self): headlines = ["Parrot programs in Python", "Second article", "Third article"] some_pub_date = datetime(2014, 5, 16, 12, 1) for headline in headlines: Article(headline=headline, pub_date=some_pub_date).save() a = Article(headline="Some headline", pub_date=some_pub_date) a.save() # You can use 'in' to test for membership... self.assertIn(a, Article.objects.all()) # ... but there will often be more efficient ways if that is all you need: self.assertTrue(Article.objects.filter(id=a.id).exists()) def test_save_primary_with_default(self): # An UPDATE attempt is skipped when a primary key has default. with self.assertNumQueries(1): PrimaryKeyWithDefault().save() def test_save_parent_primary_with_default(self): # An UPDATE attempt is skipped when an inherited primary key has # default. with self.assertNumQueries(2): ChildPrimaryKeyWithDefault().save() class ModelTest(TestCase): def test_objects_attribute_is_only_available_on_the_class_itself(self): with self.assertRaisesMessage( AttributeError, "Manager isn't accessible via Article instances" ): getattr( Article(), "objects", ) self.assertFalse(hasattr(Article(), "objects")) self.assertTrue(hasattr(Article, "objects")) def test_queryset_delete_removes_all_items_in_that_queryset(self): headlines = ["An article", "Article One", "Amazing article", "Boring article"] some_pub_date = datetime(2014, 5, 16, 12, 1) for headline in headlines: Article(headline=headline, pub_date=some_pub_date).save() self.assertQuerysetEqual( Article.objects.order_by("headline"), sorted(headlines), transform=lambda a: a.headline, ) Article.objects.filter(headline__startswith="A").delete() self.assertEqual(Article.objects.get().headline, "Boring article") def test_not_equal_and_equal_operators_behave_as_expected_on_instances(self): some_pub_date = datetime(2014, 5, 16, 12, 1) a1 = Article.objects.create(headline="First", pub_date=some_pub_date) a2 = Article.objects.create(headline="Second", pub_date=some_pub_date) self.assertNotEqual(a1, a2) self.assertEqual(a1, Article.objects.get(id__exact=a1.id)) self.assertNotEqual( Article.objects.get(id__exact=a1.id), Article.objects.get(id__exact=a2.id) ) def test_microsecond_precision(self): a9 = Article( headline="Article 9", pub_date=datetime(2005, 7, 31, 12, 30, 45, 180), ) a9.save() self.assertEqual( Article.objects.get(pk=a9.pk).pub_date, datetime(2005, 7, 31, 12, 30, 45, 180), ) def test_manually_specify_primary_key(self): # You can manually specify the primary key when creating a new object. a101 = Article( id=101, headline="Article 101", pub_date=datetime(2005, 7, 31, 12, 30, 45), ) a101.save() a101 = Article.objects.get(pk=101) self.assertEqual(a101.headline, "Article 101") def test_create_method(self): # You can create saved objects in a single step a10 = Article.objects.create( headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45), ) self.assertEqual(Article.objects.get(headline="Article 10"), a10) def test_year_lookup_edge_case(self): # Edge-case test: A year lookup should retrieve all objects in # the given year, including Jan. 1 and Dec. 31. a11 = Article.objects.create( headline="Article 11", pub_date=datetime(2008, 1, 1), ) a12 = Article.objects.create( headline="Article 12", pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), ) self.assertSequenceEqual( Article.objects.filter(pub_date__year=2008), [a11, a12], ) def test_unicode_data(self): # Unicode data works, too. a = Article( headline="\u6797\u539f \u3081\u3050\u307f", pub_date=datetime(2005, 7, 28), ) a.save() self.assertEqual( Article.objects.get(pk=a.id).headline, "\u6797\u539f \u3081\u3050\u307f" ) def test_hash_function(self): # Model instances have a hash function, so they can be used in sets # or as dictionary keys. Two models compare as equal if their primary # keys are equal. a10 = Article.objects.create( headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45), ) a11 = Article.objects.create( headline="Article 11", pub_date=datetime(2008, 1, 1), ) a12 = Article.objects.create( headline="Article 12", pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), ) s = {a10, a11, a12} self.assertIn(Article.objects.get(headline="Article 11"), s) def test_extra_method_select_argument_with_dashes_and_values(self): # The 'select' argument to extra() supports names with dashes in # them, as long as you use values(). Article.objects.bulk_create( [ Article( headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45) ), Article(headline="Article 11", pub_date=datetime(2008, 1, 1)), Article( headline="Article 12", pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), ), ] ) dicts = ( Article.objects.filter(pub_date__year=2008) .extra(select={"dashed-value": "1"}) .values("headline", "dashed-value") ) self.assertEqual( [sorted(d.items()) for d in dicts], [ [("dashed-value", 1), ("headline", "Article 11")], [("dashed-value", 1), ("headline", "Article 12")], ], ) def test_extra_method_select_argument_with_dashes(self): # If you use 'select' with extra() and names containing dashes on a # query that's *not* a values() query, those extra 'select' values # will silently be ignored. Article.objects.bulk_create( [ Article( headline="Article 10", pub_date=datetime(2005, 7, 31, 12, 30, 45) ), Article(headline="Article 11", pub_date=datetime(2008, 1, 1)), Article( headline="Article 12", pub_date=datetime(2008, 12, 31, 23, 59, 59, 999999), ), ] ) articles = Article.objects.filter(pub_date__year=2008).extra( select={"dashed-value": "1", "undashedvalue": "2"} ) self.assertEqual(articles[0].undashedvalue, 2) def test_create_relation_with_gettext_lazy(self): """ gettext_lazy objects work when saving model instances through various methods. Refs #10498. """ notlazy = "test" lazy = gettext_lazy(notlazy) Article.objects.create(headline=lazy, pub_date=datetime.now()) article = Article.objects.get() self.assertEqual(article.headline, notlazy) # test that assign + save works with Promise objects article.headline = lazy article.save() self.assertEqual(article.headline, notlazy) # test .update() Article.objects.update(headline=lazy) article = Article.objects.get() self.assertEqual(article.headline, notlazy) # still test bulk_create() Article.objects.all().delete() Article.objects.bulk_create([Article(headline=lazy, pub_date=datetime.now())]) article = Article.objects.get() self.assertEqual(article.headline, notlazy) def test_emptyqs(self): msg = "EmptyQuerySet can't be instantiated" with self.assertRaisesMessage(TypeError, msg): EmptyQuerySet() self.assertIsInstance(Article.objects.none(), EmptyQuerySet) self.assertNotIsInstance("", EmptyQuerySet) def test_emptyqs_values(self): # test for #15959 Article.objects.create(headline="foo", pub_date=datetime.now()) with self.assertNumQueries(0): qs = Article.objects.none().values_list("pk") self.assertIsInstance(qs, EmptyQuerySet) self.assertEqual(len(qs), 0) def test_emptyqs_customqs(self): # A hacky test for custom QuerySet subclass - refs #17271 Article.objects.create(headline="foo", pub_date=datetime.now()) class CustomQuerySet(models.QuerySet): def do_something(self): return "did something" qs = Article.objects.all() qs.__class__ = CustomQuerySet qs = qs.none() with self.assertNumQueries(0): self.assertEqual(len(qs), 0) self.assertIsInstance(qs, EmptyQuerySet) self.assertEqual(qs.do_something(), "did something") def test_emptyqs_values_order(self): # Tests for ticket #17712 Article.objects.create(headline="foo", pub_date=datetime.now()) with self.assertNumQueries(0): self.assertEqual( len(Article.objects.none().values_list("id").order_by("id")), 0 ) with self.assertNumQueries(0): self.assertEqual( len( Article.objects.none().filter( id__in=Article.objects.values_list("id", flat=True) ) ), 0, ) @skipUnlessDBFeature("can_distinct_on_fields") def test_emptyqs_distinct(self): # Tests for #19426 Article.objects.create(headline="foo", pub_date=datetime.now()) with self.assertNumQueries(0): self.assertEqual( len(Article.objects.none().distinct("headline", "pub_date")), 0 ) def test_ticket_20278(self): sr = SelfRef.objects.create() with self.assertRaises(ObjectDoesNotExist): SelfRef.objects.get(selfref=sr) def test_eq(self): self.assertEqual(Article(id=1), Article(id=1)) self.assertNotEqual(Article(id=1), object()) self.assertNotEqual(object(), Article(id=1)) a = Article() self.assertEqual(a, a) self.assertEqual(a, mock.ANY) self.assertNotEqual(Article(), a) def test_hash(self): # Value based on PK self.assertEqual(hash(Article(id=1)), hash(1)) msg = "Model instances without primary key value are unhashable" with self.assertRaisesMessage(TypeError, msg): # No PK value -> unhashable (because save() would then change # hash) hash(Article()) def test_missing_hash_not_inherited(self): class NoHash(models.Model): def __eq__(self, other): return super.__eq__(other) with self.assertRaisesMessage(TypeError, "unhashable type: 'NoHash'"): hash(NoHash(id=1)) def test_specified_parent_hash_inherited(self): class ParentHash(models.Model): def __eq__(self, other): return super.__eq__(other) __hash__ = models.Model.__hash__ self.assertEqual(hash(ParentHash(id=1)), 1) def test_delete_and_access_field(self): # Accessing a field after it's deleted from a model reloads its value. pub_date = datetime.now() article = Article.objects.create(headline="foo", pub_date=pub_date) new_pub_date = article.pub_date + timedelta(days=10) article.headline = "bar" article.pub_date = new_pub_date del article.headline with self.assertNumQueries(1): self.assertEqual(article.headline, "foo") # Fields that weren't deleted aren't reloaded. self.assertEqual(article.pub_date, new_pub_date) def test_multiple_objects_max_num_fetched(self): max_results = MAX_GET_RESULTS - 1 Article.objects.bulk_create( Article(headline="Area %s" % i, pub_date=datetime(2005, 7, 28)) for i in range(max_results) ) self.assertRaisesMessage( MultipleObjectsReturned, "get() returned more than one Article -- it returned %d!" % max_results, Article.objects.get, headline__startswith="Area", ) Article.objects.create( headline="Area %s" % max_results, pub_date=datetime(2005, 7, 28) ) self.assertRaisesMessage( MultipleObjectsReturned, "get() returned more than one Article -- it returned more than %d!" % max_results, Article.objects.get, headline__startswith="Area", ) class ModelLookupTest(TestCase): @classmethod def setUpTestData(cls): # Create an Article. cls.a = Article( id=None, headline="Swallow programs in Python", pub_date=datetime(2005, 7, 28), ) # Save it into the database. You have to call save() explicitly. cls.a.save() def test_all_lookup(self): # Change values by changing the attributes, then calling save(). self.a.headline = "Parrot programs in Python" self.a.save() # Article.objects.all() returns all the articles in the database. self.assertSequenceEqual(Article.objects.all(), [self.a]) def test_rich_lookup(self): # Django provides a rich database lookup API. self.assertEqual(Article.objects.get(id__exact=self.a.id), self.a) self.assertEqual(Article.objects.get(headline__startswith="Swallow"), self.a) self.assertEqual(Article.objects.get(pub_date__year=2005), self.a) self.assertEqual( Article.objects.get(pub_date__year=2005, pub_date__month=7), self.a ) self.assertEqual( Article.objects.get( pub_date__year=2005, pub_date__month=7, pub_date__day=28 ), self.a, ) self.assertEqual(Article.objects.get(pub_date__week_day=5), self.a) def test_equal_lookup(self): # The "__exact" lookup type can be omitted, as a shortcut. self.assertEqual(Article.objects.get(id=self.a.id), self.a) self.assertEqual( Article.objects.get(headline="Swallow programs in Python"), self.a ) self.assertSequenceEqual( Article.objects.filter(pub_date__year=2005), [self.a], ) self.assertSequenceEqual( Article.objects.filter(pub_date__year=2004), [], ) self.assertSequenceEqual( Article.objects.filter(pub_date__year=2005, pub_date__month=7), [self.a], ) self.assertSequenceEqual( Article.objects.filter(pub_date__week_day=5), [self.a], ) self.assertSequenceEqual( Article.objects.filter(pub_date__week_day=6), [], ) def test_does_not_exist(self): # Django raises an Article.DoesNotExist exception for get() if the # parameters don't match any object. with self.assertRaisesMessage( ObjectDoesNotExist, "Article matching query does not exist." ): Article.objects.get( id__exact=2000, ) # To avoid dict-ordering related errors check only one lookup # in single assert. with self.assertRaises(ObjectDoesNotExist): Article.objects.get(pub_date__year=2005, pub_date__month=8) with self.assertRaisesMessage( ObjectDoesNotExist, "Article matching query does not exist." ): Article.objects.get( pub_date__week_day=6, ) def test_lookup_by_primary_key(self): # Lookup by a primary key is the most common case, so Django # provides a shortcut for primary-key exact lookups. # The following is identical to articles.get(id=a.id). self.assertEqual(Article.objects.get(pk=self.a.id), self.a) # pk can be used as a shortcut for the primary key name in any query. self.assertSequenceEqual(Article.objects.filter(pk__in=[self.a.id]), [self.a]) # Model instances of the same type and same ID are considered equal. a = Article.objects.get(pk=self.a.id) b = Article.objects.get(pk=self.a.id) self.assertEqual(a, b) def test_too_many(self): # Create a very similar object a = Article( id=None, headline="Swallow bites Python", pub_date=datetime(2005, 7, 28), ) a.save() self.assertEqual(Article.objects.count(), 2) # Django raises an Article.MultipleObjectsReturned exception if the # lookup matches more than one object msg = "get() returned more than one Article -- it returned 2!" with self.assertRaisesMessage(MultipleObjectsReturned, msg): Article.objects.get( headline__startswith="Swallow", ) with self.assertRaisesMessage(MultipleObjectsReturned, msg): Article.objects.get( pub_date__year=2005, ) with self.assertRaisesMessage(MultipleObjectsReturned, msg): Article.objects.get(pub_date__year=2005, pub_date__month=7) class ConcurrentSaveTests(TransactionTestCase): available_apps = ["basic"] @skipUnlessDBFeature("test_db_allows_multiple_connections") def test_concurrent_delete_with_save(self): """ Test fetching, deleting and finally saving an object - we should get an insert in this case. """ a = Article.objects.create(headline="foo", pub_date=datetime.now()) exceptions = [] def deleter(): try: # Do not delete a directly - doing so alters its state. Article.objects.filter(pk=a.pk).delete() except Exception as e: exceptions.append(e) finally: connections[DEFAULT_DB_ALIAS].close() self.assertEqual(len(exceptions), 0) t = threading.Thread(target=deleter) t.start() t.join() a.save() self.assertEqual(Article.objects.get(pk=a.pk).headline, "foo") class ManagerTest(SimpleTestCase): QUERYSET_PROXY_METHODS = [ "none", "count", "dates", "datetimes", "distinct", "extra", "get", "get_or_create", "update_or_create", "create", "bulk_create", "bulk_update", "filter", "aggregate", "annotate", "alias", "complex_filter", "exclude", "in_bulk", "iterator", "earliest", "latest", "first", "last", "order_by", "select_for_update", "select_related", "prefetch_related", "values", "values_list", "update", "reverse", "defer", "only", "using", "exists", "contains", "explain", "_insert", "_update", "raw", "union", "intersection", "difference", ] def test_manager_methods(self): """ This test ensures that the correct set of methods from `QuerySet` are copied onto `Manager`. It's particularly useful to prevent accidentally leaking new methods into `Manager`. New `QuerySet` methods that should also be copied onto `Manager` will need to be added to `ManagerTest.QUERYSET_PROXY_METHODS`. """ self.assertEqual( sorted(BaseManager._get_queryset_methods(models.QuerySet)), sorted(self.QUERYSET_PROXY_METHODS), ) class SelectOnSaveTests(TestCase): def test_select_on_save(self): a1 = Article.objects.create(pub_date=datetime.now()) with self.assertNumQueries(1): a1.save() asos = ArticleSelectOnSave.objects.create(pub_date=datetime.now()) with self.assertNumQueries(2): asos.save() with self.assertNumQueries(1): asos.save(force_update=True) Article.objects.all().delete() with self.assertRaisesMessage( DatabaseError, "Forced update did not affect any rows." ): with self.assertNumQueries(1): asos.save(force_update=True) def test_select_on_save_lying_update(self): """ select_on_save works correctly if the database doesn't return correct information about matched rows from UPDATE. """ # Change the manager to not return "row matched" for update(). # We are going to change the Article's _base_manager class # dynamically. This is a bit of a hack, but it seems hard to # test this properly otherwise. Article's manager, because # proxy models use their parent model's _base_manager. orig_class = Article._base_manager._queryset_class class FakeQuerySet(models.QuerySet): # Make sure the _update method below is in fact called. called = False def _update(self, *args, **kwargs): FakeQuerySet.called = True super()._update(*args, **kwargs) return 0 try: Article._base_manager._queryset_class = FakeQuerySet asos = ArticleSelectOnSave.objects.create(pub_date=datetime.now()) with self.assertNumQueries(3): asos.save() self.assertTrue(FakeQuerySet.called) # This is not wanted behavior, but this is how Django has always # behaved for databases that do not return correct information # about matched rows for UPDATE. with self.assertRaisesMessage( DatabaseError, "Forced update did not affect any rows." ): asos.save(force_update=True) msg = ( "An error occurred in the current transaction. You can't " "execute queries until the end of the 'atomic' block." ) with self.assertRaisesMessage(DatabaseError, msg): asos.save(update_fields=["pub_date"]) finally: Article._base_manager._queryset_class = orig_class class ModelRefreshTests(TestCase): def test_refresh(self): a = Article.objects.create(pub_date=datetime.now()) Article.objects.create(pub_date=datetime.now()) Article.objects.filter(pk=a.pk).update(headline="new headline") with self.assertNumQueries(1): a.refresh_from_db() self.assertEqual(a.headline, "new headline") orig_pub_date = a.pub_date new_pub_date = a.pub_date + timedelta(10) Article.objects.update(headline="new headline 2", pub_date=new_pub_date) with self.assertNumQueries(1): a.refresh_from_db(fields=["headline"]) self.assertEqual(a.headline, "new headline 2") self.assertEqual(a.pub_date, orig_pub_date) with self.assertNumQueries(1): a.refresh_from_db() self.assertEqual(a.pub_date, new_pub_date) def test_unknown_kwarg(self): s = SelfRef.objects.create() msg = "refresh_from_db() got an unexpected keyword argument 'unknown_kwarg'" with self.assertRaisesMessage(TypeError, msg): s.refresh_from_db(unknown_kwarg=10) def test_lookup_in_fields(self): s = SelfRef.objects.create() msg = ( 'Found "__" in fields argument. Relations and transforms are not allowed ' "in fields." ) with self.assertRaisesMessage(ValueError, msg): s.refresh_from_db(fields=["foo__bar"]) def test_refresh_fk(self): s1 = SelfRef.objects.create() s2 = SelfRef.objects.create() s3 = SelfRef.objects.create(selfref=s1) s3_copy = SelfRef.objects.get(pk=s3.pk) s3_copy.selfref.touched = True s3.selfref = s2 s3.save() with self.assertNumQueries(1): s3_copy.refresh_from_db() with self.assertNumQueries(1): # The old related instance was thrown away (the selfref_id has # changed). It needs to be reloaded on access, so one query # executed. self.assertFalse(hasattr(s3_copy.selfref, "touched")) self.assertEqual(s3_copy.selfref, s2) def test_refresh_null_fk(self): s1 = SelfRef.objects.create() s2 = SelfRef.objects.create(selfref=s1) s2.selfref = None s2.refresh_from_db() self.assertEqual(s2.selfref, s1) def test_refresh_unsaved(self): pub_date = datetime.now() a = Article.objects.create(pub_date=pub_date) a2 = Article(id=a.pk) with self.assertNumQueries(1): a2.refresh_from_db() self.assertEqual(a2.pub_date, pub_date) self.assertEqual(a2._state.db, "default") def test_refresh_fk_on_delete_set_null(self): a = Article.objects.create( headline="Parrot programs in Python", pub_date=datetime(2005, 7, 28), ) s1 = SelfRef.objects.create(article=a) a.delete() s1.refresh_from_db() self.assertIsNone(s1.article_id) self.assertIsNone(s1.article) def test_refresh_no_fields(self): a = Article.objects.create(pub_date=datetime.now()) with self.assertNumQueries(0): a.refresh_from_db(fields=[]) def test_refresh_clears_reverse_related(self): """refresh_from_db() clear cached reverse relations.""" article = Article.objects.create( headline="Parrot programs in Python", pub_date=datetime(2005, 7, 28), ) self.assertFalse(hasattr(article, "featured")) FeaturedArticle.objects.create(article_id=article.pk) article.refresh_from_db() self.assertTrue(hasattr(article, "featured")) def test_refresh_clears_one_to_one_field(self): article = Article.objects.create( headline="Parrot programs in Python", pub_date=datetime(2005, 7, 28), ) featured = FeaturedArticle.objects.create(article_id=article.pk) self.assertEqual(featured.article.headline, "Parrot programs in Python") article.headline = "Parrot programs in Python 2.0" article.save() featured.refresh_from_db() self.assertEqual(featured.article.headline, "Parrot programs in Python 2.0") def test_prefetched_cache_cleared(self): a = Article.objects.create(pub_date=datetime(2005, 7, 28)) s = SelfRef.objects.create(article=a) # refresh_from_db() without fields=[...] a1_prefetched = Article.objects.prefetch_related("selfref_set").first() self.assertCountEqual(a1_prefetched.selfref_set.all(), [s]) s.article = None s.save() # Relation is cleared and prefetch cache is stale. self.assertCountEqual(a1_prefetched.selfref_set.all(), [s]) a1_prefetched.refresh_from_db() # Cache was cleared and new results are available. self.assertCountEqual(a1_prefetched.selfref_set.all(), []) # refresh_from_db() with fields=[...] a2_prefetched = Article.objects.prefetch_related("selfref_set").first() self.assertCountEqual(a2_prefetched.selfref_set.all(), []) s.article = a s.save() # Relation is added and prefetch cache is stale. self.assertCountEqual(a2_prefetched.selfref_set.all(), []) a2_prefetched.refresh_from_db(fields=["selfref_set"]) # Cache was cleared and new results are available. self.assertCountEqual(a2_prefetched.selfref_set.all(), [s])
54e7ea2094877dbebf4a41337311355d951fdcfcff63025864d9e4d4f516480d
""" Bare-bones model This is a basic model with only two non-primary-key fields. """ import uuid from django.db import models class Article(models.Model): headline = models.CharField(max_length=100, default="Default headline") pub_date = models.DateTimeField() class Meta: ordering = ("pub_date", "headline") def __str__(self): return self.headline class FeaturedArticle(models.Model): article = models.OneToOneField(Article, models.CASCADE, related_name="featured") class ArticleSelectOnSave(Article): class Meta: proxy = True select_on_save = True class SelfRef(models.Model): selfref = models.ForeignKey( "self", models.SET_NULL, null=True, blank=True, related_name="+", ) article = models.ForeignKey(Article, models.SET_NULL, null=True, blank=True) def __str__(self): # This method intentionally doesn't work for all cases - part # of the test for ticket #20278 return SelfRef.objects.get(selfref=self).pk class PrimaryKeyWithDefault(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4) class ChildPrimaryKeyWithDefault(PrimaryKeyWithDefault): pass
1c3b4c3fecbaf74db7fdd49eb8a45d9b6730baace222bedf970541cc533c2eaf
from xml.dom import minidom from django.core import serializers from django.core.serializers.xml_serializer import DTDForbidden from django.test import TestCase, TransactionTestCase from .tests import SerializersTestBase, SerializersTransactionTestBase class XmlSerializerTestCase(SerializersTestBase, TestCase): serializer_name = "xml" pkless_str = """<?xml version="1.0" encoding="utf-8"?> <django-objects version="1.0"> <object model="serializers.category"> <field type="CharField" name="name">Reference</field> </object> <object model="serializers.category"> <field type="CharField" name="name">Non-fiction</field> </object> </django-objects>""" mapping_ordering_str = """<?xml version="1.0" encoding="utf-8"?> <django-objects version="1.0"> <object model="serializers.article" pk="%(article_pk)s"> <field name="author" rel="ManyToOneRel" to="serializers.author">%(author_pk)s</field> <field name="headline" type="CharField">Poker has no place on ESPN</field> <field name="pub_date" type="DateTimeField">2006-06-16T11:00:00</field> <field name="categories" rel="ManyToManyRel" to="serializers.category"><object pk="%(first_category_pk)s"></object><object pk="%(second_category_pk)s"></object></field> <field name="meta_data" rel="ManyToManyRel" to="serializers.categorymetadata"></field> </object> </django-objects>""" # NOQA @staticmethod def _validate_output(serial_str): try: minidom.parseString(serial_str) except Exception: return False else: return True @staticmethod def _get_pk_values(serial_str): ret_list = [] dom = minidom.parseString(serial_str) fields = dom.getElementsByTagName("object") for field in fields: ret_list.append(field.getAttribute("pk")) return ret_list @staticmethod def _get_field_values(serial_str, field_name): ret_list = [] dom = minidom.parseString(serial_str) fields = dom.getElementsByTagName("field") for field in fields: if field.getAttribute("name") == field_name: temp = [] for child in field.childNodes: temp.append(child.nodeValue) ret_list.append("".join(temp)) return ret_list def test_control_char_failure(self): """ Serializing control characters with XML should fail as those characters are not supported in the XML 1.0 standard (except HT, LF, CR). """ self.a1.headline = "This contains \u0001 control \u0011 chars" msg = "Article.headline (pk:%s) contains unserializable characters" % self.a1.pk with self.assertRaisesMessage(ValueError, msg): serializers.serialize(self.serializer_name, [self.a1]) self.a1.headline = "HT \u0009, LF \u000A, and CR \u000D are allowed" self.assertIn( "HT \t, LF \n, and CR \r are allowed", serializers.serialize(self.serializer_name, [self.a1]), ) def test_no_dtd(self): """ The XML deserializer shouldn't allow a DTD. This is the most straightforward way to prevent all entity definitions and avoid both external entities and entity-expansion attacks. """ xml = ( '<?xml version="1.0" standalone="no"?>' '<!DOCTYPE example SYSTEM "http://example.com/example.dtd">' ) with self.assertRaises(DTDForbidden): next(serializers.deserialize("xml", xml)) class XmlSerializerTransactionTestCase( SerializersTransactionTestBase, TransactionTestCase ): serializer_name = "xml" fwd_ref_str = """<?xml version="1.0" encoding="utf-8"?> <django-objects version="1.0"> <object pk="1" model="serializers.article"> <field to="serializers.author" name="author" rel="ManyToOneRel">1</field> <field type="CharField" name="headline">Forward references pose no problem</field> <field type="DateTimeField" name="pub_date">2006-06-16T15:00:00</field> <field to="serializers.category" name="categories" rel="ManyToManyRel"> <object pk="1"></object> </field> <field to="serializers.categorymetadata" name="meta_data" rel="ManyToManyRel"></field> </object> <object pk="1" model="serializers.author"> <field type="CharField" name="name">Agnes</field> </object> <object pk="1" model="serializers.category"> <field type="CharField" name="name">Reference</field></object> </django-objects>""" # NOQA
9c29e74a57a17e2f15f64bddd634773dd7eb0ec21451a9fda2d831aebdb8458b
import importlib import unittest from io import StringIO from django.core import management, serializers from django.core.serializers.base import DeserializationError from django.test import SimpleTestCase, TestCase, TransactionTestCase from .models import Author from .tests import SerializersTestBase, SerializersTransactionTestBase try: import yaml HAS_YAML = True except ImportError: HAS_YAML = False YAML_IMPORT_ERROR_MESSAGE = r"No module named yaml" class YamlImportModuleMock: """Provides a wrapped import_module function to simulate yaml ImportError In order to run tests that verify the behavior of the YAML serializer when run on a system that has yaml installed (like the django CI server), mock import_module, so that it raises an ImportError when the yaml serializer is being imported. The importlib.import_module() call is being made in the serializers.register_serializer(). Refs: #12756 """ def __init__(self): self._import_module = importlib.import_module def import_module(self, module_path): if module_path == serializers.BUILTIN_SERIALIZERS["yaml"]: raise ImportError(YAML_IMPORT_ERROR_MESSAGE) return self._import_module(module_path) class NoYamlSerializerTestCase(SimpleTestCase): """Not having pyyaml installed provides a misleading error Refs: #12756 """ @classmethod def setUpClass(cls): """Removes imported yaml and stubs importlib.import_module""" super().setUpClass() cls._import_module_mock = YamlImportModuleMock() importlib.import_module = cls._import_module_mock.import_module # clear out cached serializers to emulate yaml missing serializers._serializers = {} @classmethod def tearDownClass(cls): """Puts yaml back if necessary""" super().tearDownClass() importlib.import_module = cls._import_module_mock._import_module # clear out cached serializers to clean out BadSerializer instances serializers._serializers = {} def test_serializer_pyyaml_error_message(self): """Using yaml serializer without pyyaml raises ImportError""" jane = Author(name="Jane") with self.assertRaises(ImportError): serializers.serialize("yaml", [jane]) def test_deserializer_pyyaml_error_message(self): """Using yaml deserializer without pyyaml raises ImportError""" with self.assertRaises(ImportError): serializers.deserialize("yaml", "") def test_dumpdata_pyyaml_error_message(self): """Calling dumpdata produces an error when yaml package missing""" with self.assertRaisesMessage( management.CommandError, YAML_IMPORT_ERROR_MESSAGE ): management.call_command("dumpdata", format="yaml") @unittest.skipUnless(HAS_YAML, "No yaml library detected") class YamlSerializerTestCase(SerializersTestBase, TestCase): serializer_name = "yaml" pkless_str = """- model: serializers.category pk: null fields: name: Reference - model: serializers.category fields: name: Non-fiction""" mapping_ordering_str = ( """- model: serializers.article pk: %(article_pk)s fields: author: %(author_pk)s headline: Poker has no place on ESPN pub_date: 2006-06-16 11:00:00 categories:""" + ( " [%(first_category_pk)s, %(second_category_pk)s]" if HAS_YAML and yaml.__version__ < "5.1" else "\n - %(first_category_pk)s\n - %(second_category_pk)s" ) + """ meta_data: [] """ ) @staticmethod def _validate_output(serial_str): try: yaml.safe_load(StringIO(serial_str)) except Exception: return False else: return True @staticmethod def _get_pk_values(serial_str): ret_list = [] stream = StringIO(serial_str) for obj_dict in yaml.safe_load(stream): ret_list.append(obj_dict["pk"]) return ret_list @staticmethod def _get_field_values(serial_str, field_name): ret_list = [] stream = StringIO(serial_str) for obj_dict in yaml.safe_load(stream): if "fields" in obj_dict and field_name in obj_dict["fields"]: field_value = obj_dict["fields"][field_name] # yaml.safe_load will return non-string objects for some # of the fields we are interested in, this ensures that # everything comes back as a string if isinstance(field_value, str): ret_list.append(field_value) else: ret_list.append(str(field_value)) return ret_list def test_yaml_deserializer_exception(self): with self.assertRaises(DeserializationError): for obj in serializers.deserialize("yaml", "{"): pass @unittest.skipUnless(HAS_YAML, "No yaml library detected") class YamlSerializerTransactionTestCase( SerializersTransactionTestBase, TransactionTestCase ): serializer_name = "yaml" fwd_ref_str = """- model: serializers.article pk: 1 fields: headline: Forward references pose no problem pub_date: 2006-06-16 15:00:00 categories: [1] author: 1 - model: serializers.category pk: 1 fields: name: Reference - model: serializers.author pk: 1 fields: name: Agnes"""
da3f97d83358436059883da881c5686dcf54af60dec4fe752df2b52e000dda3f
import pickle from datetime import datetime from functools import partialmethod from io import StringIO from unittest import mock, skipIf from django.core import serializers from django.core.serializers import SerializerDoesNotExist from django.core.serializers.base import PickleSerializer, ProgressBar from django.db import connection, transaction from django.http import HttpResponse from django.test import SimpleTestCase, override_settings, skipUnlessDBFeature from django.test.utils import Approximate, ignore_warnings from django.utils.deprecation import RemovedInDjango50Warning from .models import ( Actor, Article, Author, AuthorProfile, BaseModel, Category, Child, ComplexModel, Movie, Player, ProxyBaseModel, ProxyProxyBaseModel, Score, Team, ) @override_settings( SERIALIZATION_MODULES={ "json2": "django.core.serializers.json", } ) class SerializerRegistrationTests(SimpleTestCase): def setUp(self): self.old_serializers = serializers._serializers serializers._serializers = {} def tearDown(self): serializers._serializers = self.old_serializers def test_register(self): "Registering a new serializer populates the full registry. Refs #14823" serializers.register_serializer("json3", "django.core.serializers.json") public_formats = serializers.get_public_serializer_formats() self.assertIn("json3", public_formats) self.assertIn("json2", public_formats) self.assertIn("xml", public_formats) def test_unregister(self): """ Unregistering a serializer doesn't cause the registry to be repopulated. """ serializers.unregister_serializer("xml") serializers.register_serializer("json3", "django.core.serializers.json") public_formats = serializers.get_public_serializer_formats() self.assertNotIn("xml", public_formats) self.assertIn("json3", public_formats) def test_unregister_unknown_serializer(self): with self.assertRaises(SerializerDoesNotExist): serializers.unregister_serializer("nonsense") def test_builtin_serializers(self): "Requesting a list of serializer formats populates the registry" all_formats = set(serializers.get_serializer_formats()) public_formats = set(serializers.get_public_serializer_formats()) self.assertIn("xml", all_formats), self.assertIn("xml", public_formats) self.assertIn("json2", all_formats) self.assertIn("json2", public_formats) self.assertIn("python", all_formats) self.assertNotIn("python", public_formats) def test_get_unknown_serializer(self): """ #15889: get_serializer('nonsense') raises a SerializerDoesNotExist """ with self.assertRaises(SerializerDoesNotExist): serializers.get_serializer("nonsense") with self.assertRaises(KeyError): serializers.get_serializer("nonsense") # SerializerDoesNotExist is instantiated with the nonexistent format with self.assertRaisesMessage(SerializerDoesNotExist, "nonsense"): serializers.get_serializer("nonsense") def test_get_unknown_deserializer(self): with self.assertRaises(SerializerDoesNotExist): serializers.get_deserializer("nonsense") class SerializersTestBase: serializer_name = None # Set by subclasses to the serialization format name @classmethod def setUpTestData(cls): sports = Category.objects.create(name="Sports") music = Category.objects.create(name="Music") op_ed = Category.objects.create(name="Op-Ed") cls.joe = Author.objects.create(name="Joe") cls.jane = Author.objects.create(name="Jane") cls.a1 = Article( author=cls.jane, headline="Poker has no place on ESPN", pub_date=datetime(2006, 6, 16, 11, 00), ) cls.a1.save() cls.a1.categories.set([sports, op_ed]) cls.a2 = Article( author=cls.joe, headline="Time to reform copyright", pub_date=datetime(2006, 6, 16, 13, 00, 11, 345), ) cls.a2.save() cls.a2.categories.set([music, op_ed]) def test_serialize(self): """Basic serialization works.""" serial_str = serializers.serialize(self.serializer_name, Article.objects.all()) self.assertTrue(self._validate_output(serial_str)) def test_serializer_roundtrip(self): """Serialized content can be deserialized.""" serial_str = serializers.serialize(self.serializer_name, Article.objects.all()) models = list(serializers.deserialize(self.serializer_name, serial_str)) self.assertEqual(len(models), 2) def test_serialize_to_stream(self): obj = ComplexModel(field1="first", field2="second", field3="third") obj.save_base(raw=True) # Serialize the test database to a stream for stream in (StringIO(), HttpResponse()): serializers.serialize(self.serializer_name, [obj], indent=2, stream=stream) # Serialize normally for a comparison string_data = serializers.serialize(self.serializer_name, [obj], indent=2) # The two are the same if isinstance(stream, StringIO): self.assertEqual(string_data, stream.getvalue()) else: self.assertEqual(string_data, stream.content.decode()) def test_serialize_specific_fields(self): obj = ComplexModel(field1="first", field2="second", field3="third") obj.save_base(raw=True) # Serialize then deserialize the test database serialized_data = serializers.serialize( self.serializer_name, [obj], indent=2, fields=("field1", "field3") ) result = next(serializers.deserialize(self.serializer_name, serialized_data)) # The deserialized object contains data in only the serialized fields. self.assertEqual(result.object.field1, "first") self.assertEqual(result.object.field2, "") self.assertEqual(result.object.field3, "third") def test_altering_serialized_output(self): """ The ability to create new objects by modifying serialized content. """ old_headline = "Poker has no place on ESPN" new_headline = "Poker has no place on television" serial_str = serializers.serialize(self.serializer_name, Article.objects.all()) serial_str = serial_str.replace(old_headline, new_headline) models = list(serializers.deserialize(self.serializer_name, serial_str)) # Prior to saving, old headline is in place self.assertTrue(Article.objects.filter(headline=old_headline)) self.assertFalse(Article.objects.filter(headline=new_headline)) for model in models: model.save() # After saving, new headline is in place self.assertTrue(Article.objects.filter(headline=new_headline)) self.assertFalse(Article.objects.filter(headline=old_headline)) def test_one_to_one_as_pk(self): """ If you use your own primary key field (such as a OneToOneField), it doesn't appear in the serialized field list - it replaces the pk identifier. """ AuthorProfile.objects.create( author=self.joe, date_of_birth=datetime(1970, 1, 1) ) serial_str = serializers.serialize( self.serializer_name, AuthorProfile.objects.all() ) self.assertFalse(self._get_field_values(serial_str, "author")) for obj in serializers.deserialize(self.serializer_name, serial_str): self.assertEqual(obj.object.pk, self.joe.pk) def test_serialize_field_subset(self): """Output can be restricted to a subset of fields""" valid_fields = ("headline", "pub_date") invalid_fields = ("author", "categories") serial_str = serializers.serialize( self.serializer_name, Article.objects.all(), fields=valid_fields ) for field_name in invalid_fields: self.assertFalse(self._get_field_values(serial_str, field_name)) for field_name in valid_fields: self.assertTrue(self._get_field_values(serial_str, field_name)) def test_serialize_unicode_roundtrip(self): """Unicode makes the roundtrip intact""" actor_name = "Za\u017c\u00f3\u0142\u0107" movie_title = "G\u0119\u015bl\u0105 ja\u017a\u0144" ac = Actor(name=actor_name) mv = Movie(title=movie_title, actor=ac) ac.save() mv.save() serial_str = serializers.serialize(self.serializer_name, [mv]) self.assertEqual(self._get_field_values(serial_str, "title")[0], movie_title) self.assertEqual(self._get_field_values(serial_str, "actor")[0], actor_name) obj_list = list(serializers.deserialize(self.serializer_name, serial_str)) mv_obj = obj_list[0].object self.assertEqual(mv_obj.title, movie_title) def test_unicode_serialization(self): unicode_name = "יוניקוד" data = serializers.serialize(self.serializer_name, [Author(name=unicode_name)]) self.assertIn(unicode_name, data) objs = list(serializers.deserialize(self.serializer_name, data)) self.assertEqual(objs[0].object.name, unicode_name) def test_serialize_progressbar(self): fake_stdout = StringIO() serializers.serialize( self.serializer_name, Article.objects.all(), progress_output=fake_stdout, object_count=Article.objects.count(), ) self.assertTrue( fake_stdout.getvalue().endswith( "[" + "." * ProgressBar.progress_width + "]\n" ) ) def test_serialize_superfluous_queries(self): """Ensure no superfluous queries are made when serializing ForeignKeys #17602 """ ac = Actor(name="Actor name") ac.save() mv = Movie(title="Movie title", actor_id=ac.pk) mv.save() with self.assertNumQueries(0): serializers.serialize(self.serializer_name, [mv]) def test_serialize_prefetch_related_m2m(self): # One query for the Article table and one for each prefetched m2m # field. with self.assertNumQueries(3): serializers.serialize( self.serializer_name, Article.objects.prefetch_related("categories", "meta_data"), ) # One query for the Article table, and two m2m queries for each # article. with self.assertNumQueries(5): serializers.serialize(self.serializer_name, Article.objects.all()) def test_serialize_with_null_pk(self): """ Serialized data with no primary key results in a model instance with no id """ category = Category(name="Reference") serial_str = serializers.serialize(self.serializer_name, [category]) pk_value = self._get_pk_values(serial_str)[0] self.assertFalse(pk_value) cat_obj = list(serializers.deserialize(self.serializer_name, serial_str))[ 0 ].object self.assertIsNone(cat_obj.id) def test_float_serialization(self): """Float values serialize and deserialize intact""" sc = Score(score=3.4) sc.save() serial_str = serializers.serialize(self.serializer_name, [sc]) deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str)) self.assertEqual(deserial_objs[0].object.score, Approximate(3.4, places=1)) def test_deferred_field_serialization(self): author = Author.objects.create(name="Victor Hugo") author = Author.objects.defer("name").get(pk=author.pk) serial_str = serializers.serialize(self.serializer_name, [author]) deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str)) self.assertIsInstance(deserial_objs[0].object, Author) def test_custom_field_serialization(self): """Custom fields serialize and deserialize intact""" team_str = "Spartak Moskva" player = Player() player.name = "Soslan Djanaev" player.rank = 1 player.team = Team(team_str) player.save() serial_str = serializers.serialize(self.serializer_name, Player.objects.all()) team = self._get_field_values(serial_str, "team") self.assertTrue(team) self.assertEqual(team[0], team_str) deserial_objs = list(serializers.deserialize(self.serializer_name, serial_str)) self.assertEqual( deserial_objs[0].object.team.to_string(), player.team.to_string() ) def test_pre_1000ad_date(self): """Year values before 1000AD are properly formatted""" # Regression for #12524 -- dates before 1000AD get prefixed # 0's on the year a = Article.objects.create( author=self.jane, headline="Nobody remembers the early years", pub_date=datetime(1, 2, 3, 4, 5, 6), ) serial_str = serializers.serialize(self.serializer_name, [a]) date_values = self._get_field_values(serial_str, "pub_date") self.assertEqual(date_values[0].replace("T", " "), "0001-02-03 04:05:06") def test_pkless_serialized_strings(self): """ Serialized strings without PKs can be turned into models """ deserial_objs = list( serializers.deserialize(self.serializer_name, self.pkless_str) ) for obj in deserial_objs: self.assertFalse(obj.object.id) obj.save() self.assertEqual(Category.objects.count(), 5) def test_deterministic_mapping_ordering(self): """Mapping such as fields should be deterministically ordered. (#24558)""" output = serializers.serialize(self.serializer_name, [self.a1], indent=2) categories = self.a1.categories.values_list("pk", flat=True) self.assertEqual( output, self.mapping_ordering_str % { "article_pk": self.a1.pk, "author_pk": self.a1.author_id, "first_category_pk": categories[0], "second_category_pk": categories[1], }, ) def test_deserialize_force_insert(self): """Deserialized content can be saved with force_insert as a parameter.""" serial_str = serializers.serialize(self.serializer_name, [self.a1]) deserial_obj = list(serializers.deserialize(self.serializer_name, serial_str))[ 0 ] with mock.patch("django.db.models.Model") as mock_model: deserial_obj.save(force_insert=False) mock_model.save_base.assert_called_with( deserial_obj.object, raw=True, using=None, force_insert=False ) @skipUnlessDBFeature("can_defer_constraint_checks") def test_serialize_proxy_model(self): BaseModel.objects.create(parent_data=1) base_objects = BaseModel.objects.all() proxy_objects = ProxyBaseModel.objects.all() proxy_proxy_objects = ProxyProxyBaseModel.objects.all() base_data = serializers.serialize("json", base_objects) proxy_data = serializers.serialize("json", proxy_objects) proxy_proxy_data = serializers.serialize("json", proxy_proxy_objects) self.assertEqual(base_data, proxy_data.replace("proxy", "")) self.assertEqual(base_data, proxy_proxy_data.replace("proxy", "")) def test_serialize_inherited_fields(self): child_1 = Child.objects.create(parent_data="a", child_data="b") child_2 = Child.objects.create(parent_data="c", child_data="d") child_1.parent_m2m.add(child_2) child_data = serializers.serialize(self.serializer_name, [child_1, child_2]) self.assertEqual(self._get_field_values(child_data, "parent_m2m"), []) self.assertEqual(self._get_field_values(child_data, "parent_data"), []) class SerializerAPITests(SimpleTestCase): def test_stream_class(self): class File: def __init__(self): self.lines = [] def write(self, line): self.lines.append(line) def getvalue(self): return "".join(self.lines) class Serializer(serializers.json.Serializer): stream_class = File serializer = Serializer() data = serializer.serialize([Score(id=1, score=3.4)]) self.assertIs(serializer.stream_class, File) self.assertIsInstance(serializer.stream, File) self.assertEqual( data, '[{"model": "serializers.score", "pk": 1, "fields": {"score": 3.4}}]' ) class SerializersTransactionTestBase: available_apps = ["serializers"] @skipUnlessDBFeature("supports_forward_references") def test_forward_refs(self): """ Objects ids can be referenced before they are defined in the serialization data. """ # The deserialization process needs to run in a transaction in order # to test forward reference handling. with transaction.atomic(): objs = serializers.deserialize(self.serializer_name, self.fwd_ref_str) with connection.constraint_checks_disabled(): for obj in objs: obj.save() for model_cls in (Category, Author, Article): self.assertEqual(model_cls.objects.count(), 1) art_obj = Article.objects.all()[0] self.assertEqual(art_obj.categories.count(), 1) self.assertEqual(art_obj.author.name, "Agnes") class PickleSerializerTests(SimpleTestCase): @ignore_warnings(category=RemovedInDjango50Warning) def test_serializer_protocol(self): serializer = PickleSerializer(protocol=3) self.assertEqual(serializer.protocol, 3) # If protocol is not provided, it defaults to pickle.HIGHEST_PROTOCOL serializer = PickleSerializer() self.assertEqual(serializer.protocol, pickle.HIGHEST_PROTOCOL) @ignore_warnings(category=RemovedInDjango50Warning) def test_serializer_loads_dumps(self): serializer = PickleSerializer() test_data = "test data" dump = serializer.dumps(test_data) self.assertEqual(serializer.loads(dump), test_data) def test_serializer_warning(self): msg = ( "PickleSerializer is deprecated due to its security risk. Use " "JSONSerializer instead." ) with self.assertRaisesMessage(RemovedInDjango50Warning, msg): PickleSerializer() def register_tests(test_class, method_name, test_func, exclude=()): """ Dynamically create serializer tests to ensure that all registered serializers are automatically tested. """ for format_ in serializers.get_serializer_formats(): if format_ == "geojson" or format_ in exclude: continue decorated_func = skipIf( isinstance(serializers.get_serializer(format_), serializers.BadSerializer), "The Python library for the %s serializer is not installed." % format_, )(test_func) setattr( test_class, method_name % format_, partialmethod(decorated_func, format_) )
e56c277fc5995b8888f4d5bfd603e9d68c141a576e2b9158072ed1e583eb4e90
import decimal import json import re from django.core import serializers from django.core.serializers.base import DeserializationError from django.db import models from django.test import TestCase, TransactionTestCase from django.test.utils import isolate_apps from .models import Score from .tests import SerializersTestBase, SerializersTransactionTestBase class JsonlSerializerTestCase(SerializersTestBase, TestCase): serializer_name = "jsonl" pkless_str = [ '{"pk": null,"model": "serializers.category","fields": {"name": "Reference"}}', '{"model": "serializers.category","fields": {"name": "Non-fiction"}}', ] pkless_str = "\n".join([s.replace("\n", "") for s in pkless_str]) mapping_ordering_str = ( '{"model": "serializers.article","pk": %(article_pk)s,' '"fields": {' '"author": %(author_pk)s,' '"headline": "Poker has no place on ESPN",' '"pub_date": "2006-06-16T11:00:00",' '"categories": [%(first_category_pk)s,%(second_category_pk)s],' '"meta_data": []}}\n' ) @staticmethod def _validate_output(serial_str): try: for line in serial_str.split("\n"): if line: json.loads(line) except Exception: return False else: return True @staticmethod def _get_pk_values(serial_str): serial_list = [json.loads(line) for line in serial_str.split("\n") if line] return [obj_dict["pk"] for obj_dict in serial_list] @staticmethod def _get_field_values(serial_str, field_name): serial_list = [json.loads(line) for line in serial_str.split("\n") if line] return [ obj_dict["fields"][field_name] for obj_dict in serial_list if field_name in obj_dict["fields"] ] def test_no_indentation(self): s = serializers.jsonl.Serializer() json_data = s.serialize([Score(score=5.0), Score(score=6.0)], indent=2) for line in json_data.splitlines(): self.assertIsNone(re.search(r".+,\s*$", line)) @isolate_apps("serializers") def test_custom_encoder(self): class ScoreDecimal(models.Model): score = models.DecimalField() class CustomJSONEncoder(json.JSONEncoder): def default(self, o): if isinstance(o, decimal.Decimal): return str(o) return super().default(o) s = serializers.jsonl.Serializer() json_data = s.serialize( [ScoreDecimal(score=decimal.Decimal(1.0))], cls=CustomJSONEncoder, ) self.assertIn('"fields": {"score": "1"}', json_data) def test_json_deserializer_exception(self): with self.assertRaises(DeserializationError): for obj in serializers.deserialize("jsonl", """[{"pk":1}"""): pass def test_helpful_error_message_invalid_pk(self): """ If there is an invalid primary key, the error message contains the model associated with it. """ test_string = ( '{"pk": "badpk","model": "serializers.player",' '"fields": {"name": "Bob","rank": 1,"team": "Team"}}' ) with self.assertRaisesMessage( DeserializationError, "(serializers.player:pk=badpk)" ): list(serializers.deserialize("jsonl", test_string)) def test_helpful_error_message_invalid_field(self): """ If there is an invalid field value, the error message contains the model associated with it. """ test_string = ( '{"pk": "1","model": "serializers.player",' '"fields": {"name": "Bob","rank": "invalidint","team": "Team"}}' ) expected = "(serializers.player:pk=1) field_value was 'invalidint'" with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("jsonl", test_string)) def test_helpful_error_message_for_foreign_keys(self): """ Invalid foreign keys with a natural key throws a helpful error message, such as what the failing key is. """ test_string = ( '{"pk": 1, "model": "serializers.category",' '"fields": {' '"name": "Unknown foreign key",' '"meta_data": ["doesnotexist","metadata"]}}' ) key = ["doesnotexist", "metadata"] expected = "(serializers.category:pk=1) field_value was '%r'" % key with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("jsonl", test_string)) def test_helpful_error_message_for_many2many_non_natural(self): """ Invalid many-to-many keys throws a helpful error message. """ test_strings = [ """{ "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "categories": [1, "doesnotexist"] } }""", """{ "pk": 1, "model": "serializers.author", "fields": {"name": "Agnes"} }""", """{ "pk": 1, "model": "serializers.category", "fields": {"name": "Reference"} }""", ] test_string = "\n".join([s.replace("\n", "") for s in test_strings]) expected = "(serializers.article:pk=1) field_value was 'doesnotexist'" with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("jsonl", test_string)) def test_helpful_error_message_for_many2many_natural1(self): """ Invalid many-to-many keys throws a helpful error message where one of a list of natural keys is invalid. """ test_strings = [ """{ "pk": 1, "model": "serializers.categorymetadata", "fields": {"kind": "author","name": "meta1","value": "Agnes"} }""", """{ "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "meta_data": [ ["author", "meta1"], ["doesnotexist", "meta1"], ["author", "meta1"] ] } }""", """{ "pk": 1, "model": "serializers.author", "fields": {"name": "Agnes"} }""", ] test_string = "\n".join([s.replace("\n", "") for s in test_strings]) key = ["doesnotexist", "meta1"] expected = "(serializers.article:pk=1) field_value was '%r'" % key with self.assertRaisesMessage(DeserializationError, expected): for obj in serializers.deserialize("jsonl", test_string): obj.save() def test_helpful_error_message_for_many2many_natural2(self): """ Invalid many-to-many keys throws a helpful error message where a natural many-to-many key has only a single value. """ test_strings = [ """{ "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "meta_data": [1, "doesnotexist"] } }""", """{ "pk": 1, "model": "serializers.categorymetadata", "fields": {"kind": "author","name": "meta1","value": "Agnes"} }""", """{ "pk": 1, "model": "serializers.author", "fields": {"name": "Agnes"} }""", ] test_string = "\n".join([s.replace("\n", "") for s in test_strings]) expected = "(serializers.article:pk=1) field_value was 'doesnotexist'" with self.assertRaisesMessage(DeserializationError, expected): for obj in serializers.deserialize("jsonl", test_string, ignore=False): obj.save() def test_helpful_error_message_for_many2many_not_iterable(self): """ Not iterable many-to-many field value throws a helpful error message. """ test_string = ( '{"pk": 1,"model": "serializers.m2mdata","fields": {"data": null}}' ) expected = "(serializers.m2mdata:pk=1) field_value was 'None'" with self.assertRaisesMessage(DeserializationError, expected): next(serializers.deserialize("jsonl", test_string, ignore=False)) class JsonSerializerTransactionTestCase( SerializersTransactionTestBase, TransactionTestCase ): serializer_name = "jsonl" fwd_ref_str = [ """{ "pk": 1, "model": "serializers.article", "fields": { "headline": "Forward references pose no problem", "pub_date": "2006-06-16T15:00:00", "categories": [1], "author": 1 } }""", """{ "pk": 1, "model": "serializers.category", "fields": {"name": "Reference"} }""", """{ "pk": 1, "model": "serializers.author", "fields": {"name": "Agnes"} }""", ] fwd_ref_str = "\n".join([s.replace("\n", "") for s in fwd_ref_str])
f208a5f7c9282dd1f611c50ed2b7639c7309c24c125302349439097d8236cb33
from django.core import serializers from django.db import connection from django.test import TestCase from .models import ( Child, FKAsPKNoNaturalKey, FKDataNaturalKey, NaturalKeyAnchor, NaturalKeyThing, NaturalPKWithDefault, ) from .tests import register_tests class NaturalKeySerializerTests(TestCase): pass def natural_key_serializer_test(self, format): # Create all the objects defined in the test data with connection.constraint_checks_disabled(): objects = [ NaturalKeyAnchor.objects.create(id=1100, data="Natural Key Anghor"), FKDataNaturalKey.objects.create(id=1101, data_id=1100), FKDataNaturalKey.objects.create(id=1102, data_id=None), ] # Serialize the test database serialized_data = serializers.serialize( format, objects, indent=2, use_natural_foreign_keys=True ) for obj in serializers.deserialize(format, serialized_data): obj.save() # Assert that the deserialized data is the same # as the original source for obj in objects: instance = obj.__class__.objects.get(id=obj.pk) self.assertEqual( obj.data, instance.data, "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % ( obj.pk, obj.data, type(obj.data), instance, type(instance.data), ), ) def natural_key_test(self, format): book1 = { "data": "978-1590597255", "title": "The Definitive Guide to Django: Web Development Done Right", } book2 = {"data": "978-1590599969", "title": "Practical Django Projects"} # Create the books. adrian = NaturalKeyAnchor.objects.create(**book1) james = NaturalKeyAnchor.objects.create(**book2) # Serialize the books. string_data = serializers.serialize( format, NaturalKeyAnchor.objects.all(), indent=2, use_natural_foreign_keys=True, use_natural_primary_keys=True, ) # Delete one book (to prove that the natural key generation will only # restore the primary keys of books found in the database via the # get_natural_key manager method). james.delete() # Deserialize and test. books = list(serializers.deserialize(format, string_data)) self.assertEqual(len(books), 2) self.assertEqual(books[0].object.title, book1["title"]) self.assertEqual(books[0].object.pk, adrian.pk) self.assertEqual(books[1].object.title, book2["title"]) self.assertIsNone(books[1].object.pk) def natural_pk_mti_test(self, format): """ If serializing objects in a multi-table inheritance relationship using natural primary keys, the natural foreign key for the parent is output in the fields of the child so it's possible to relate the child to the parent when deserializing. """ child_1 = Child.objects.create(parent_data="1", child_data="1") child_2 = Child.objects.create(parent_data="2", child_data="2") string_data = serializers.serialize( format, [child_1.parent_ptr, child_2.parent_ptr, child_2, child_1], use_natural_foreign_keys=True, use_natural_primary_keys=True, ) child_1.delete() child_2.delete() for obj in serializers.deserialize(format, string_data): obj.save() children = Child.objects.all() self.assertEqual(len(children), 2) for child in children: # If it's possible to find the superclass from the subclass and it's # the correct superclass, it's working. self.assertEqual(child.child_data, child.parent_data) def forward_ref_fk_test(self, format): t1 = NaturalKeyThing.objects.create(key="t1") t2 = NaturalKeyThing.objects.create(key="t2", other_thing=t1) t1.other_thing = t2 t1.save() string_data = serializers.serialize( format, [t1, t2], use_natural_primary_keys=True, use_natural_foreign_keys=True, ) NaturalKeyThing.objects.all().delete() objs_with_deferred_fields = [] for obj in serializers.deserialize( format, string_data, handle_forward_references=True ): obj.save() if obj.deferred_fields: objs_with_deferred_fields.append(obj) for obj in objs_with_deferred_fields: obj.save_deferred_fields() t1 = NaturalKeyThing.objects.get(key="t1") t2 = NaturalKeyThing.objects.get(key="t2") self.assertEqual(t1.other_thing, t2) self.assertEqual(t2.other_thing, t1) def forward_ref_fk_with_error_test(self, format): t1 = NaturalKeyThing.objects.create(key="t1") t2 = NaturalKeyThing.objects.create(key="t2", other_thing=t1) t1.other_thing = t2 t1.save() string_data = serializers.serialize( format, [t1], use_natural_primary_keys=True, use_natural_foreign_keys=True, ) NaturalKeyThing.objects.all().delete() objs_with_deferred_fields = [] for obj in serializers.deserialize( format, string_data, handle_forward_references=True ): obj.save() if obj.deferred_fields: objs_with_deferred_fields.append(obj) obj = objs_with_deferred_fields[0] msg = "NaturalKeyThing matching query does not exist" with self.assertRaisesMessage(serializers.base.DeserializationError, msg): obj.save_deferred_fields() def forward_ref_m2m_test(self, format): t1 = NaturalKeyThing.objects.create(key="t1") t2 = NaturalKeyThing.objects.create(key="t2") t3 = NaturalKeyThing.objects.create(key="t3") t1.other_things.set([t2, t3]) string_data = serializers.serialize( format, [t1, t2, t3], use_natural_primary_keys=True, use_natural_foreign_keys=True, ) NaturalKeyThing.objects.all().delete() objs_with_deferred_fields = [] for obj in serializers.deserialize( format, string_data, handle_forward_references=True ): obj.save() if obj.deferred_fields: objs_with_deferred_fields.append(obj) for obj in objs_with_deferred_fields: obj.save_deferred_fields() t1 = NaturalKeyThing.objects.get(key="t1") t2 = NaturalKeyThing.objects.get(key="t2") t3 = NaturalKeyThing.objects.get(key="t3") self.assertCountEqual(t1.other_things.all(), [t2, t3]) def forward_ref_m2m_with_error_test(self, format): t1 = NaturalKeyThing.objects.create(key="t1") t2 = NaturalKeyThing.objects.create(key="t2") t3 = NaturalKeyThing.objects.create(key="t3") t1.other_things.set([t2, t3]) t1.save() string_data = serializers.serialize( format, [t1, t2], use_natural_primary_keys=True, use_natural_foreign_keys=True, ) NaturalKeyThing.objects.all().delete() objs_with_deferred_fields = [] for obj in serializers.deserialize( format, string_data, handle_forward_references=True ): obj.save() if obj.deferred_fields: objs_with_deferred_fields.append(obj) obj = objs_with_deferred_fields[0] msg = "NaturalKeyThing matching query does not exist" with self.assertRaisesMessage(serializers.base.DeserializationError, msg): obj.save_deferred_fields() def pk_with_default(self, format): """ The deserializer works with natural keys when the primary key has a default value. """ obj = NaturalPKWithDefault.objects.create(name="name") string_data = serializers.serialize( format, NaturalPKWithDefault.objects.all(), use_natural_foreign_keys=True, use_natural_primary_keys=True, ) objs = list(serializers.deserialize(format, string_data)) self.assertEqual(len(objs), 1) self.assertEqual(objs[0].object.pk, obj.pk) def fk_as_pk_natural_key_not_called(self, format): """ The deserializer doesn't rely on natural keys when a model has a custom primary key that is a ForeignKey. """ o1 = NaturalKeyAnchor.objects.create(data="978-1590599969") o2 = FKAsPKNoNaturalKey.objects.create(pk_fk=o1) serialized_data = serializers.serialize(format, [o1, o2]) deserialized_objects = list(serializers.deserialize(format, serialized_data)) self.assertEqual(len(deserialized_objects), 2) for obj in deserialized_objects: self.assertEqual(obj.object.pk, o1.pk) # Dynamically register tests for each serializer register_tests( NaturalKeySerializerTests, "test_%s_natural_key_serializer", natural_key_serializer_test, ) register_tests( NaturalKeySerializerTests, "test_%s_serializer_natural_keys", natural_key_test ) register_tests( NaturalKeySerializerTests, "test_%s_serializer_natural_pks_mti", natural_pk_mti_test ) register_tests( NaturalKeySerializerTests, "test_%s_forward_references_fks", forward_ref_fk_test ) register_tests( NaturalKeySerializerTests, "test_%s_forward_references_fk_errors", forward_ref_fk_with_error_test, ) register_tests( NaturalKeySerializerTests, "test_%s_forward_references_m2ms", forward_ref_m2m_test ) register_tests( NaturalKeySerializerTests, "test_%s_forward_references_m2m_errors", forward_ref_m2m_with_error_test, ) register_tests(NaturalKeySerializerTests, "test_%s_pk_with_default", pk_with_default) register_tests( NaturalKeySerializerTests, "test_%s_fk_as_pk_natural_key_not_called", fk_as_pk_natural_key_not_called, )
06eb09992f7e04f4bbe525097724e9000d6cb9255a5f9d222c3fc71c41d694cd
""" A test spanning all the capabilities of all the serializers. This class defines sample data and a dynamically generated test case that is capable of testing the capabilities of the serializers. This includes all valid data values, plus forward, backwards and self references. """ import datetime import decimal import uuid from django.core import serializers from django.db import connection, models from django.test import TestCase from .models import ( Anchor, AutoNowDateTimeData, BigIntegerData, BinaryData, BooleanData, BooleanPKData, CharData, CharPKData, DateData, DatePKData, DateTimeData, DateTimePKData, DecimalData, DecimalPKData, EmailData, EmailPKData, ExplicitInheritBaseModel, FileData, FilePathData, FilePathPKData, FKData, FKDataToField, FKDataToO2O, FKSelfData, FKToUUID, FloatData, FloatPKData, GenericData, GenericIPAddressData, GenericIPAddressPKData, InheritAbstractModel, InheritBaseModel, IntegerData, IntegerPKData, Intermediate, LengthModel, M2MData, M2MIntermediateData, M2MSelfData, ModifyingSaveData, O2OData, PositiveBigIntegerData, PositiveIntegerData, PositiveIntegerPKData, PositiveSmallIntegerData, PositiveSmallIntegerPKData, SlugData, SlugPKData, SmallData, SmallPKData, Tag, TextData, TimeData, UniqueAnchor, UUIDData, UUIDDefaultData, ) from .tests import register_tests # A set of functions that can be used to recreate # test data objects of various kinds. # The save method is a raw base model save, to make # sure that the data in the database matches the # exact test case. def data_create(pk, klass, data): instance = klass(id=pk) instance.data = data models.Model.save_base(instance, raw=True) return [instance] def generic_create(pk, klass, data): instance = klass(id=pk) instance.data = data[0] models.Model.save_base(instance, raw=True) for tag in data[1:]: instance.tags.create(data=tag) return [instance] def fk_create(pk, klass, data): instance = klass(id=pk) setattr(instance, "data_id", data) models.Model.save_base(instance, raw=True) return [instance] def m2m_create(pk, klass, data): instance = klass(id=pk) models.Model.save_base(instance, raw=True) instance.data.set(data) return [instance] def im2m_create(pk, klass, data): instance = klass(id=pk) models.Model.save_base(instance, raw=True) return [instance] def im_create(pk, klass, data): instance = klass(id=pk) instance.right_id = data["right"] instance.left_id = data["left"] if "extra" in data: instance.extra = data["extra"] models.Model.save_base(instance, raw=True) return [instance] def o2o_create(pk, klass, data): instance = klass() instance.data_id = data models.Model.save_base(instance, raw=True) return [instance] def pk_create(pk, klass, data): instance = klass() instance.data = data models.Model.save_base(instance, raw=True) return [instance] def inherited_create(pk, klass, data): instance = klass(id=pk, **data) # This isn't a raw save because: # 1) we're testing inheritance, not field behavior, so none # of the field values need to be protected. # 2) saving the child class and having the parent created # automatically is easier than manually creating both. models.Model.save(instance) created = [instance] for klass in instance._meta.parents: created.append(klass.objects.get(id=pk)) return created # A set of functions that can be used to compare # test data objects of various kinds def data_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) if klass == BinaryData and data is not None: testcase.assertEqual( bytes(data), bytes(instance.data), "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % ( pk, repr(bytes(data)), type(data), repr(bytes(instance.data)), type(instance.data), ), ) else: testcase.assertEqual( data, instance.data, "Objects with PK=%d not equal; expected '%s' (%s), got '%s' (%s)" % ( pk, data, type(data), instance, type(instance.data), ), ) def generic_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) testcase.assertEqual(data[0], instance.data) testcase.assertEqual(data[1:], [t.data for t in instance.tags.order_by("id")]) def fk_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) testcase.assertEqual(data, instance.data_id) def m2m_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) testcase.assertEqual(data, [obj.id for obj in instance.data.order_by("id")]) def im2m_compare(testcase, pk, klass, data): klass.objects.get(id=pk) # actually nothing else to check, the instance just should exist def im_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) testcase.assertEqual(data["left"], instance.left_id) testcase.assertEqual(data["right"], instance.right_id) if "extra" in data: testcase.assertEqual(data["extra"], instance.extra) else: testcase.assertEqual("doesn't matter", instance.extra) def o2o_compare(testcase, pk, klass, data): instance = klass.objects.get(data=data) testcase.assertEqual(data, instance.data_id) def pk_compare(testcase, pk, klass, data): instance = klass.objects.get(data=data) testcase.assertEqual(data, instance.data) def inherited_compare(testcase, pk, klass, data): instance = klass.objects.get(id=pk) for key, value in data.items(): testcase.assertEqual(value, getattr(instance, key)) # Define some data types. Each data type is # actually a pair of functions; one to create # and one to compare objects of that type data_obj = (data_create, data_compare) generic_obj = (generic_create, generic_compare) fk_obj = (fk_create, fk_compare) m2m_obj = (m2m_create, m2m_compare) im2m_obj = (im2m_create, im2m_compare) im_obj = (im_create, im_compare) o2o_obj = (o2o_create, o2o_compare) pk_obj = (pk_create, pk_compare) inherited_obj = (inherited_create, inherited_compare) uuid_obj = uuid.uuid4() test_data = [ # Format: (data type, PK value, Model Class, data) (data_obj, 1, BinaryData, memoryview(b"\x05\xFD\x00")), (data_obj, 2, BinaryData, None), (data_obj, 5, BooleanData, True), (data_obj, 6, BooleanData, False), (data_obj, 7, BooleanData, None), (data_obj, 10, CharData, "Test Char Data"), (data_obj, 11, CharData, ""), (data_obj, 12, CharData, "None"), (data_obj, 13, CharData, "null"), (data_obj, 14, CharData, "NULL"), (data_obj, 15, CharData, None), # (We use something that will fit into a latin1 database encoding here, # because that is still the default used on many system setups.) (data_obj, 16, CharData, "\xa5"), (data_obj, 20, DateData, datetime.date(2006, 6, 16)), (data_obj, 21, DateData, None), (data_obj, 30, DateTimeData, datetime.datetime(2006, 6, 16, 10, 42, 37)), (data_obj, 31, DateTimeData, None), (data_obj, 40, EmailData, "[email protected]"), (data_obj, 41, EmailData, None), (data_obj, 42, EmailData, ""), (data_obj, 50, FileData, "file:///foo/bar/whiz.txt"), # (data_obj, 51, FileData, None), (data_obj, 52, FileData, ""), (data_obj, 60, FilePathData, "/foo/bar/whiz.txt"), (data_obj, 61, FilePathData, None), (data_obj, 62, FilePathData, ""), (data_obj, 70, DecimalData, decimal.Decimal("12.345")), (data_obj, 71, DecimalData, decimal.Decimal("-12.345")), (data_obj, 72, DecimalData, decimal.Decimal("0.0")), (data_obj, 73, DecimalData, None), (data_obj, 74, FloatData, 12.345), (data_obj, 75, FloatData, -12.345), (data_obj, 76, FloatData, 0.0), (data_obj, 77, FloatData, None), (data_obj, 80, IntegerData, 123456789), (data_obj, 81, IntegerData, -123456789), (data_obj, 82, IntegerData, 0), (data_obj, 83, IntegerData, None), # (XX, ImageData (data_obj, 95, GenericIPAddressData, "fe80:1424:2223:6cff:fe8a:2e8a:2151:abcd"), (data_obj, 96, GenericIPAddressData, None), (data_obj, 110, PositiveBigIntegerData, 9223372036854775807), (data_obj, 111, PositiveBigIntegerData, None), (data_obj, 120, PositiveIntegerData, 123456789), (data_obj, 121, PositiveIntegerData, None), (data_obj, 130, PositiveSmallIntegerData, 12), (data_obj, 131, PositiveSmallIntegerData, None), (data_obj, 140, SlugData, "this-is-a-slug"), (data_obj, 141, SlugData, None), (data_obj, 142, SlugData, ""), (data_obj, 150, SmallData, 12), (data_obj, 151, SmallData, -12), (data_obj, 152, SmallData, 0), (data_obj, 153, SmallData, None), ( data_obj, 160, TextData, """This is a long piece of text. It contains line breaks. Several of them. The end.""", ), (data_obj, 161, TextData, ""), (data_obj, 162, TextData, None), (data_obj, 170, TimeData, datetime.time(10, 42, 37)), (data_obj, 171, TimeData, None), (generic_obj, 200, GenericData, ["Generic Object 1", "tag1", "tag2"]), (generic_obj, 201, GenericData, ["Generic Object 2", "tag2", "tag3"]), (data_obj, 300, Anchor, "Anchor 1"), (data_obj, 301, Anchor, "Anchor 2"), (data_obj, 302, UniqueAnchor, "UAnchor 1"), (fk_obj, 400, FKData, 300), # Post reference (fk_obj, 401, FKData, 500), # Pre reference (fk_obj, 402, FKData, None), # Empty reference (m2m_obj, 410, M2MData, []), # Empty set (m2m_obj, 411, M2MData, [300, 301]), # Post reference (m2m_obj, 412, M2MData, [500, 501]), # Pre reference (m2m_obj, 413, M2MData, [300, 301, 500, 501]), # Pre and Post reference (o2o_obj, None, O2OData, 300), # Post reference (o2o_obj, None, O2OData, 500), # Pre reference (fk_obj, 430, FKSelfData, 431), # Pre reference (fk_obj, 431, FKSelfData, 430), # Post reference (fk_obj, 432, FKSelfData, None), # Empty reference (m2m_obj, 440, M2MSelfData, []), (m2m_obj, 441, M2MSelfData, []), (m2m_obj, 442, M2MSelfData, [440, 441]), (m2m_obj, 443, M2MSelfData, [445, 446]), (m2m_obj, 444, M2MSelfData, [440, 441, 445, 446]), (m2m_obj, 445, M2MSelfData, []), (m2m_obj, 446, M2MSelfData, []), (fk_obj, 450, FKDataToField, "UAnchor 1"), (fk_obj, 451, FKDataToField, "UAnchor 2"), (fk_obj, 452, FKDataToField, None), (fk_obj, 460, FKDataToO2O, 300), (im2m_obj, 470, M2MIntermediateData, None), # testing post- and pre-references and extra fields (im_obj, 480, Intermediate, {"right": 300, "left": 470}), (im_obj, 481, Intermediate, {"right": 300, "left": 490}), (im_obj, 482, Intermediate, {"right": 500, "left": 470}), (im_obj, 483, Intermediate, {"right": 500, "left": 490}), (im_obj, 484, Intermediate, {"right": 300, "left": 470, "extra": "extra"}), (im_obj, 485, Intermediate, {"right": 300, "left": 490, "extra": "extra"}), (im_obj, 486, Intermediate, {"right": 500, "left": 470, "extra": "extra"}), (im_obj, 487, Intermediate, {"right": 500, "left": 490, "extra": "extra"}), (im2m_obj, 490, M2MIntermediateData, []), (data_obj, 500, Anchor, "Anchor 3"), (data_obj, 501, Anchor, "Anchor 4"), (data_obj, 502, UniqueAnchor, "UAnchor 2"), (pk_obj, 601, BooleanPKData, True), (pk_obj, 602, BooleanPKData, False), (pk_obj, 610, CharPKData, "Test Char PKData"), (pk_obj, 620, DatePKData, datetime.date(2006, 6, 16)), (pk_obj, 630, DateTimePKData, datetime.datetime(2006, 6, 16, 10, 42, 37)), (pk_obj, 640, EmailPKData, "[email protected]"), # (pk_obj, 650, FilePKData, 'file:///foo/bar/whiz.txt'), (pk_obj, 660, FilePathPKData, "/foo/bar/whiz.txt"), (pk_obj, 670, DecimalPKData, decimal.Decimal("12.345")), (pk_obj, 671, DecimalPKData, decimal.Decimal("-12.345")), (pk_obj, 672, DecimalPKData, decimal.Decimal("0.0")), (pk_obj, 673, FloatPKData, 12.345), (pk_obj, 674, FloatPKData, -12.345), (pk_obj, 675, FloatPKData, 0.0), (pk_obj, 680, IntegerPKData, 123456789), (pk_obj, 681, IntegerPKData, -123456789), (pk_obj, 682, IntegerPKData, 0), # (XX, ImagePKData (pk_obj, 695, GenericIPAddressPKData, "fe80:1424:2223:6cff:fe8a:2e8a:2151:abcd"), (pk_obj, 720, PositiveIntegerPKData, 123456789), (pk_obj, 730, PositiveSmallIntegerPKData, 12), (pk_obj, 740, SlugPKData, "this-is-a-slug"), (pk_obj, 750, SmallPKData, 12), (pk_obj, 751, SmallPKData, -12), (pk_obj, 752, SmallPKData, 0), # (pk_obj, 760, TextPKData, """This is a long piece of text. # It contains line breaks. # Several of them. # The end."""), # (pk_obj, 770, TimePKData, datetime.time(10, 42, 37)), # (pk_obj, 790, XMLPKData, "<foo></foo>"), (pk_obj, 791, UUIDData, uuid_obj), (fk_obj, 792, FKToUUID, uuid_obj), (pk_obj, 793, UUIDDefaultData, uuid_obj), (data_obj, 800, AutoNowDateTimeData, datetime.datetime(2006, 6, 16, 10, 42, 37)), (data_obj, 810, ModifyingSaveData, 42), (inherited_obj, 900, InheritAbstractModel, {"child_data": 37, "parent_data": 42}), ( inherited_obj, 910, ExplicitInheritBaseModel, {"child_data": 37, "parent_data": 42}, ), (inherited_obj, 920, InheritBaseModel, {"child_data": 37, "parent_data": 42}), (data_obj, 1000, BigIntegerData, 9223372036854775807), (data_obj, 1001, BigIntegerData, -9223372036854775808), (data_obj, 1002, BigIntegerData, 0), (data_obj, 1003, BigIntegerData, None), (data_obj, 1004, LengthModel, 0), (data_obj, 1005, LengthModel, 1), ] # Because Oracle treats the empty string as NULL, Oracle is expected to fail # when field.empty_strings_allowed is True and the value is None; skip these # tests. if connection.features.interprets_empty_strings_as_nulls: test_data = [ data for data in test_data if not ( data[0] == data_obj and data[2]._meta.get_field("data").empty_strings_allowed and data[3] is None ) ] class SerializerDataTests(TestCase): pass def serializerTest(self, format): # FK to an object with PK of 0. This won't work on MySQL without the # NO_AUTO_VALUE_ON_ZERO SQL mode since it won't let you create an object # with an autoincrement primary key of 0. if connection.features.allows_auto_pk_0: test_data.extend( [ (data_obj, 0, Anchor, "Anchor 0"), (fk_obj, 465, FKData, 0), ] ) # Create all the objects defined in the test data objects = [] instance_count = {} for (func, pk, klass, datum) in test_data: with connection.constraint_checks_disabled(): objects.extend(func[0](pk, klass, datum)) # Get a count of the number of objects created for each class for klass in instance_count: instance_count[klass] = klass.objects.count() # Add the generic tagged objects to the object list objects.extend(Tag.objects.all()) # Serialize the test database serialized_data = serializers.serialize(format, objects, indent=2) for obj in serializers.deserialize(format, serialized_data): obj.save() # Assert that the deserialized data is the same # as the original source for (func, pk, klass, datum) in test_data: func[1](self, pk, klass, datum) # Assert that the number of objects deserialized is the # same as the number that was serialized. for klass, count in instance_count.items(): self.assertEqual(count, klass.objects.count()) register_tests(SerializerDataTests, "test_%s_serializer", serializerTest)
627869c687c288de4415e382c3a39891582846f79e1c38b2247066638f16c556
import datetime import decimal import json import re from django.core import serializers from django.core.serializers.base import DeserializationError from django.core.serializers.json import DjangoJSONEncoder from django.db import models from django.test import SimpleTestCase, TestCase, TransactionTestCase from django.test.utils import isolate_apps from django.utils.translation import gettext_lazy, override from .models import Score from .tests import SerializersTestBase, SerializersTransactionTestBase class JsonSerializerTestCase(SerializersTestBase, TestCase): serializer_name = "json" pkless_str = """[ { "pk": null, "model": "serializers.category", "fields": {"name": "Reference"} }, { "model": "serializers.category", "fields": {"name": "Non-fiction"} }]""" mapping_ordering_str = """[ { "model": "serializers.article", "pk": %(article_pk)s, "fields": { "author": %(author_pk)s, "headline": "Poker has no place on ESPN", "pub_date": "2006-06-16T11:00:00", "categories": [ %(first_category_pk)s, %(second_category_pk)s ], "meta_data": [] } } ] """ @staticmethod def _validate_output(serial_str): try: json.loads(serial_str) except Exception: return False else: return True @staticmethod def _get_pk_values(serial_str): serial_list = json.loads(serial_str) return [obj_dict["pk"] for obj_dict in serial_list] @staticmethod def _get_field_values(serial_str, field_name): serial_list = json.loads(serial_str) return [ obj_dict["fields"][field_name] for obj_dict in serial_list if field_name in obj_dict["fields"] ] def test_indentation_whitespace(self): s = serializers.json.Serializer() json_data = s.serialize([Score(score=5.0), Score(score=6.0)], indent=2) for line in json_data.splitlines(): if re.search(r".+,\s*$", line): self.assertEqual(line, line.rstrip()) @isolate_apps("serializers") def test_custom_encoder(self): class ScoreDecimal(models.Model): score = models.DecimalField() class CustomJSONEncoder(json.JSONEncoder): def default(self, o): if isinstance(o, decimal.Decimal): return str(o) return super().default(o) s = serializers.json.Serializer() json_data = s.serialize( [ScoreDecimal(score=decimal.Decimal(1.0))], cls=CustomJSONEncoder ) self.assertIn('"fields": {"score": "1"}', json_data) def test_json_deserializer_exception(self): with self.assertRaises(DeserializationError): for obj in serializers.deserialize("json", """[{"pk":1}"""): pass def test_helpful_error_message_invalid_pk(self): """ If there is an invalid primary key, the error message should contain the model associated with it. """ test_string = """[{ "pk": "badpk", "model": "serializers.player", "fields": { "name": "Bob", "rank": 1, "team": "Team" } }]""" with self.assertRaisesMessage( DeserializationError, "(serializers.player:pk=badpk)" ): list(serializers.deserialize("json", test_string)) def test_helpful_error_message_invalid_field(self): """ If there is an invalid field value, the error message should contain the model associated with it. """ test_string = """[{ "pk": "1", "model": "serializers.player", "fields": { "name": "Bob", "rank": "invalidint", "team": "Team" } }]""" expected = "(serializers.player:pk=1) field_value was 'invalidint'" with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("json", test_string)) def test_helpful_error_message_for_foreign_keys(self): """ Invalid foreign keys with a natural key should throw a helpful error message, such as what the failing key is. """ test_string = """[{ "pk": 1, "model": "serializers.category", "fields": { "name": "Unknown foreign key", "meta_data": [ "doesnotexist", "metadata" ] } }]""" key = ["doesnotexist", "metadata"] expected = "(serializers.category:pk=1) field_value was '%r'" % key with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("json", test_string)) def test_helpful_error_message_for_many2many_non_natural(self): """ Invalid many-to-many keys should throw a helpful error message. """ test_string = """[{ "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "categories": [1, "doesnotexist"] } }, { "pk": 1, "model": "serializers.author", "fields": { "name": "Agnes" } }, { "pk": 1, "model": "serializers.category", "fields": { "name": "Reference" } }]""" expected = "(serializers.article:pk=1) field_value was 'doesnotexist'" with self.assertRaisesMessage(DeserializationError, expected): list(serializers.deserialize("json", test_string)) def test_helpful_error_message_for_many2many_natural1(self): """ Invalid many-to-many keys should throw a helpful error message. This tests the code path where one of a list of natural keys is invalid. """ test_string = """[{ "pk": 1, "model": "serializers.categorymetadata", "fields": { "kind": "author", "name": "meta1", "value": "Agnes" } }, { "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "meta_data": [ ["author", "meta1"], ["doesnotexist", "meta1"], ["author", "meta1"] ] } }, { "pk": 1, "model": "serializers.author", "fields": { "name": "Agnes" } }]""" key = ["doesnotexist", "meta1"] expected = "(serializers.article:pk=1) field_value was '%r'" % key with self.assertRaisesMessage(DeserializationError, expected): for obj in serializers.deserialize("json", test_string): obj.save() def test_helpful_error_message_for_many2many_natural2(self): """ Invalid many-to-many keys should throw a helpful error message. This tests the code path where a natural many-to-many key has only a single value. """ test_string = """[{ "pk": 1, "model": "serializers.article", "fields": { "author": 1, "headline": "Unknown many to many", "pub_date": "2014-09-15T10:35:00", "meta_data": [1, "doesnotexist"] } }, { "pk": 1, "model": "serializers.categorymetadata", "fields": { "kind": "author", "name": "meta1", "value": "Agnes" } }, { "pk": 1, "model": "serializers.author", "fields": { "name": "Agnes" } }]""" expected = "(serializers.article:pk=1) field_value was 'doesnotexist'" with self.assertRaisesMessage(DeserializationError, expected): for obj in serializers.deserialize("json", test_string, ignore=False): obj.save() def test_helpful_error_message_for_many2many_not_iterable(self): """ Not iterable many-to-many field value throws a helpful error message. """ test_string = """[{ "pk": 1, "model": "serializers.m2mdata", "fields": {"data": null} }]""" expected = "(serializers.m2mdata:pk=1) field_value was 'None'" with self.assertRaisesMessage(DeserializationError, expected): next(serializers.deserialize("json", test_string, ignore=False)) class JsonSerializerTransactionTestCase( SerializersTransactionTestBase, TransactionTestCase ): serializer_name = "json" fwd_ref_str = """[ { "pk": 1, "model": "serializers.article", "fields": { "headline": "Forward references pose no problem", "pub_date": "2006-06-16T15:00:00", "categories": [1], "author": 1 } }, { "pk": 1, "model": "serializers.category", "fields": { "name": "Reference" } }, { "pk": 1, "model": "serializers.author", "fields": { "name": "Agnes" } }]""" class DjangoJSONEncoderTests(SimpleTestCase): def test_lazy_string_encoding(self): self.assertEqual( json.dumps({"lang": gettext_lazy("French")}, cls=DjangoJSONEncoder), '{"lang": "French"}', ) with override("fr"): self.assertEqual( json.dumps({"lang": gettext_lazy("French")}, cls=DjangoJSONEncoder), '{"lang": "Fran\\u00e7ais"}', ) def test_timedelta(self): duration = datetime.timedelta(days=1, hours=2, seconds=3) self.assertEqual( json.dumps({"duration": duration}, cls=DjangoJSONEncoder), '{"duration": "P1DT02H00M03S"}', ) duration = datetime.timedelta(0) self.assertEqual( json.dumps({"duration": duration}, cls=DjangoJSONEncoder), '{"duration": "P0DT00H00M00S"}', )
1fb8d2d0d625e71b67f76124d801be4b3f613bd92f5b7f4f5c8d1f07c70a2b23
from django.core.serializers.base import DeserializedObject from django.test import SimpleTestCase from .models import Author class TestDeserializedObjectTests(SimpleTestCase): def test_repr(self): author = Author(name="John", pk=1) deserial_obj = DeserializedObject(obj=author) self.assertEqual( repr(deserial_obj), "<DeserializedObject: serializers.Author(pk=1)>" )
99abbf9afa37e438889e1b079f3c2cfceeb33fda597545199ff4dab208dab801
from datetime import date from django import forms from django.contrib.admin.models import ADDITION, CHANGE, DELETION, LogEntry from django.contrib.admin.options import ( HORIZONTAL, VERTICAL, ModelAdmin, TabularInline, get_content_type_for_model, ) from django.contrib.admin.sites import AdminSite from django.contrib.admin.widgets import ( AdminDateWidget, AdminRadioSelect, AutocompleteSelect, AutocompleteSelectMultiple, ) from django.contrib.auth.models import User from django.db import models from django.forms.widgets import Select from django.test import SimpleTestCase, TestCase from django.test.utils import isolate_apps from .models import Band, Concert, Song class MockRequest: pass class MockSuperUser: def has_perm(self, perm, obj=None): return True request = MockRequest() request.user = MockSuperUser() class ModelAdminTests(TestCase): @classmethod def setUpTestData(cls): cls.band = Band.objects.create( name="The Doors", bio="", sign_date=date(1965, 1, 1), ) def setUp(self): self.site = AdminSite() def test_modeladmin_str(self): ma = ModelAdmin(Band, self.site) self.assertEqual(str(ma), "modeladmin.ModelAdmin") def test_default_attributes(self): ma = ModelAdmin(Band, self.site) self.assertEqual(ma.actions, ()) self.assertEqual(ma.inlines, ()) # form/fields/fieldsets interaction ############################## def test_default_fields(self): ma = ModelAdmin(Band, self.site) self.assertEqual( list(ma.get_form(request).base_fields), ["name", "bio", "sign_date"] ) self.assertEqual(list(ma.get_fields(request)), ["name", "bio", "sign_date"]) self.assertEqual( list(ma.get_fields(request, self.band)), ["name", "bio", "sign_date"] ) self.assertIsNone(ma.get_exclude(request, self.band)) def test_default_fieldsets(self): # fieldsets_add and fieldsets_change should return a special data structure that # is used in the templates. They should generate the "right thing" whether we # have specified a custom form, the fields argument, or nothing at all. # # Here's the default case. There are no custom form_add/form_change methods, # no fields argument, and no fieldsets argument. ma = ModelAdmin(Band, self.site) self.assertEqual( ma.get_fieldsets(request), [(None, {"fields": ["name", "bio", "sign_date"]})], ) self.assertEqual( ma.get_fieldsets(request, self.band), [(None, {"fields": ["name", "bio", "sign_date"]})], ) def test_get_fieldsets(self): # get_fieldsets() is called when figuring out form fields (#18681). class BandAdmin(ModelAdmin): def get_fieldsets(self, request, obj=None): return [(None, {"fields": ["name", "bio"]})] ma = BandAdmin(Band, self.site) form = ma.get_form(None) self.assertEqual(form._meta.fields, ["name", "bio"]) class InlineBandAdmin(TabularInline): model = Concert fk_name = "main_band" can_delete = False def get_fieldsets(self, request, obj=None): return [(None, {"fields": ["day", "transport"]})] ma = InlineBandAdmin(Band, self.site) form = ma.get_formset(None).form self.assertEqual(form._meta.fields, ["day", "transport"]) def test_lookup_allowed_allows_nonexistent_lookup(self): """ A lookup_allowed allows a parameter whose field lookup doesn't exist. (#21129). """ class BandAdmin(ModelAdmin): fields = ["name"] ma = BandAdmin(Band, self.site) self.assertTrue(ma.lookup_allowed("name__nonexistent", "test_value")) @isolate_apps("modeladmin") def test_lookup_allowed_onetoone(self): class Department(models.Model): code = models.CharField(max_length=4, unique=True) class Employee(models.Model): department = models.ForeignKey(Department, models.CASCADE, to_field="code") class EmployeeProfile(models.Model): employee = models.OneToOneField(Employee, models.CASCADE) class EmployeeInfo(models.Model): employee = models.OneToOneField(Employee, models.CASCADE) description = models.CharField(max_length=100) class EmployeeProfileAdmin(ModelAdmin): list_filter = [ "employee__employeeinfo__description", "employee__department__code", ] ma = EmployeeProfileAdmin(EmployeeProfile, self.site) # Reverse OneToOneField self.assertIs( ma.lookup_allowed("employee__employeeinfo__description", "test_value"), True ) # OneToOneField and ForeignKey self.assertIs( ma.lookup_allowed("employee__department__code", "test_value"), True ) def test_field_arguments(self): # If fields is specified, fieldsets_add and fieldsets_change should # just stick the fields into a formsets structure and return it. class BandAdmin(ModelAdmin): fields = ["name"] ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_fields(request)), ["name"]) self.assertEqual(list(ma.get_fields(request, self.band)), ["name"]) self.assertEqual(ma.get_fieldsets(request), [(None, {"fields": ["name"]})]) self.assertEqual( ma.get_fieldsets(request, self.band), [(None, {"fields": ["name"]})] ) def test_field_arguments_restricted_on_form(self): # If fields or fieldsets is specified, it should exclude fields on the # Form class to the fields specified. This may cause errors to be # raised in the db layer if required model fields aren't in fields/ # fieldsets, but that's preferable to ghost errors where a field in the # Form class isn't being displayed because it's not in fields/fieldsets. # Using `fields`. class BandAdmin(ModelAdmin): fields = ["name"] ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name"]) self.assertEqual(list(ma.get_form(request, self.band).base_fields), ["name"]) # Using `fieldsets`. class BandAdmin(ModelAdmin): fieldsets = [(None, {"fields": ["name"]})] ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name"]) self.assertEqual(list(ma.get_form(request, self.band).base_fields), ["name"]) # Using `exclude`. class BandAdmin(ModelAdmin): exclude = ["bio"] ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"]) # You can also pass a tuple to `exclude`. class BandAdmin(ModelAdmin): exclude = ("bio",) ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"]) # Using `fields` and `exclude`. class BandAdmin(ModelAdmin): fields = ["name", "bio"] exclude = ["bio"] ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name"]) def test_custom_form_meta_exclude_with_readonly(self): """ The custom ModelForm's `Meta.exclude` is respected when used in conjunction with `ModelAdmin.readonly_fields` and when no `ModelAdmin.exclude` is defined (#14496). """ # With ModelAdmin class AdminBandForm(forms.ModelForm): class Meta: model = Band exclude = ["bio"] class BandAdmin(ModelAdmin): readonly_fields = ["name"] form = AdminBandForm ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["sign_date"]) # With InlineModelAdmin class AdminConcertForm(forms.ModelForm): class Meta: model = Concert exclude = ["day"] class ConcertInline(TabularInline): readonly_fields = ["transport"] form = AdminConcertForm fk_name = "main_band" model = Concert class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["main_band", "opening_band", "id", "DELETE"], ) def test_custom_formfield_override_readonly(self): class AdminBandForm(forms.ModelForm): name = forms.CharField() class Meta: exclude = () model = Band class BandAdmin(ModelAdmin): form = AdminBandForm readonly_fields = ["name"] ma = BandAdmin(Band, self.site) # `name` shouldn't appear in base_fields because it's part of # readonly_fields. self.assertEqual(list(ma.get_form(request).base_fields), ["bio", "sign_date"]) # But it should appear in get_fields()/fieldsets() so it can be # displayed as read-only. self.assertEqual(list(ma.get_fields(request)), ["bio", "sign_date", "name"]) self.assertEqual( list(ma.get_fieldsets(request)), [(None, {"fields": ["bio", "sign_date", "name"]})], ) def test_custom_form_meta_exclude(self): """ The custom ModelForm's `Meta.exclude` is overridden if `ModelAdmin.exclude` or `InlineModelAdmin.exclude` are defined (#14496). """ # With ModelAdmin class AdminBandForm(forms.ModelForm): class Meta: model = Band exclude = ["bio"] class BandAdmin(ModelAdmin): exclude = ["name"] form = AdminBandForm ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["bio", "sign_date"]) # With InlineModelAdmin class AdminConcertForm(forms.ModelForm): class Meta: model = Concert exclude = ["day"] class ConcertInline(TabularInline): exclude = ["transport"] form = AdminConcertForm fk_name = "main_band" model = Concert class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["main_band", "opening_band", "day", "id", "DELETE"], ) def test_overriding_get_exclude(self): class BandAdmin(ModelAdmin): def get_exclude(self, request, obj=None): return ["name"] self.assertEqual( list(BandAdmin(Band, self.site).get_form(request).base_fields), ["bio", "sign_date"], ) def test_get_exclude_overrides_exclude(self): class BandAdmin(ModelAdmin): exclude = ["bio"] def get_exclude(self, request, obj=None): return ["name"] self.assertEqual( list(BandAdmin(Band, self.site).get_form(request).base_fields), ["bio", "sign_date"], ) def test_get_exclude_takes_obj(self): class BandAdmin(ModelAdmin): def get_exclude(self, request, obj=None): if obj: return ["sign_date"] return ["name"] self.assertEqual( list(BandAdmin(Band, self.site).get_form(request, self.band).base_fields), ["name", "bio"], ) def test_custom_form_validation(self): # If a form is specified, it should use it allowing custom validation # to work properly. This won't break any of the admin widgets or media. class AdminBandForm(forms.ModelForm): delete = forms.BooleanField() class BandAdmin(ModelAdmin): form = AdminBandForm ma = BandAdmin(Band, self.site) self.assertEqual( list(ma.get_form(request).base_fields), ["name", "bio", "sign_date", "delete"], ) self.assertEqual( type(ma.get_form(request).base_fields["sign_date"].widget), AdminDateWidget ) def test_form_exclude_kwarg_override(self): """ The `exclude` kwarg passed to `ModelAdmin.get_form()` overrides all other declarations (#8999). """ class AdminBandForm(forms.ModelForm): class Meta: model = Band exclude = ["name"] class BandAdmin(ModelAdmin): exclude = ["sign_date"] form = AdminBandForm def get_form(self, request, obj=None, **kwargs): kwargs["exclude"] = ["bio"] return super().get_form(request, obj, **kwargs) ma = BandAdmin(Band, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["name", "sign_date"]) def test_formset_exclude_kwarg_override(self): """ The `exclude` kwarg passed to `InlineModelAdmin.get_formset()` overrides all other declarations (#8999). """ class AdminConcertForm(forms.ModelForm): class Meta: model = Concert exclude = ["day"] class ConcertInline(TabularInline): exclude = ["transport"] form = AdminConcertForm fk_name = "main_band" model = Concert def get_formset(self, request, obj=None, **kwargs): kwargs["exclude"] = ["opening_band"] return super().get_formset(request, obj, **kwargs) class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["main_band", "day", "transport", "id", "DELETE"], ) def test_formset_overriding_get_exclude_with_form_fields(self): class AdminConcertForm(forms.ModelForm): class Meta: model = Concert fields = ["main_band", "opening_band", "day", "transport"] class ConcertInline(TabularInline): form = AdminConcertForm fk_name = "main_band" model = Concert def get_exclude(self, request, obj=None): return ["opening_band"] class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["main_band", "day", "transport", "id", "DELETE"], ) def test_formset_overriding_get_exclude_with_form_exclude(self): class AdminConcertForm(forms.ModelForm): class Meta: model = Concert exclude = ["day"] class ConcertInline(TabularInline): form = AdminConcertForm fk_name = "main_band" model = Concert def get_exclude(self, request, obj=None): return ["opening_band"] class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["main_band", "day", "transport", "id", "DELETE"], ) def test_raw_id_fields_widget_override(self): """ The autocomplete_fields, raw_id_fields, and radio_fields widgets may overridden by specifying a widget in get_formset(). """ class ConcertInline(TabularInline): model = Concert fk_name = "main_band" raw_id_fields = ("opening_band",) def get_formset(self, request, obj=None, **kwargs): kwargs["widgets"] = {"opening_band": Select} return super().get_formset(request, obj, **kwargs) class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) band_widget = ( list(ma.get_formsets_with_inlines(request))[0][0]() .forms[0] .fields["opening_band"] .widget ) # Without the override this would be ForeignKeyRawIdWidget. self.assertIsInstance(band_widget, Select) def test_queryset_override(self): # If the queryset of a ModelChoiceField in a custom form is overridden, # RelatedFieldWidgetWrapper doesn't mess that up. band2 = Band.objects.create( name="The Beatles", bio="", sign_date=date(1962, 1, 1) ) ma = ModelAdmin(Concert, self.site) form = ma.get_form(request)() self.assertHTMLEqual( str(form["main_band"]), '<div class="related-widget-wrapper">' '<select name="main_band" id="id_main_band" required>' '<option value="" selected>---------</option>' '<option value="%d">The Beatles</option>' '<option value="%d">The Doors</option>' "</select></div>" % (band2.id, self.band.id), ) class AdminConcertForm(forms.ModelForm): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.fields["main_band"].queryset = Band.objects.filter( name="The Doors" ) class ConcertAdminWithForm(ModelAdmin): form = AdminConcertForm ma = ConcertAdminWithForm(Concert, self.site) form = ma.get_form(request)() self.assertHTMLEqual( str(form["main_band"]), '<div class="related-widget-wrapper">' '<select name="main_band" id="id_main_band" required>' '<option value="" selected>---------</option>' '<option value="%d">The Doors</option>' "</select></div>" % self.band.id, ) def test_regression_for_ticket_15820(self): """ `obj` is passed from `InlineModelAdmin.get_fieldsets()` to `InlineModelAdmin.get_formset()`. """ class CustomConcertForm(forms.ModelForm): class Meta: model = Concert fields = ["day"] class ConcertInline(TabularInline): model = Concert fk_name = "main_band" def get_formset(self, request, obj=None, **kwargs): if obj: kwargs["form"] = CustomConcertForm return super().get_formset(request, obj, **kwargs) class BandAdmin(ModelAdmin): inlines = [ConcertInline] Concert.objects.create(main_band=self.band, opening_band=self.band, day=1) ma = BandAdmin(Band, self.site) inline_instances = ma.get_inline_instances(request) fieldsets = list(inline_instances[0].get_fieldsets(request)) self.assertEqual( fieldsets[0][1]["fields"], ["main_band", "opening_band", "day", "transport"] ) fieldsets = list( inline_instances[0].get_fieldsets(request, inline_instances[0].model) ) self.assertEqual(fieldsets[0][1]["fields"], ["day"]) # radio_fields behavior ########################################### def test_default_foreign_key_widget(self): # First, without any radio_fields specified, the widgets for ForeignKey # and fields with choices specified ought to be a basic Select widget. # ForeignKey widgets in the admin are wrapped with RelatedFieldWidgetWrapper so # they need to be handled properly when type checking. For Select fields, all of # the choices lists have a first entry of dashes. cma = ModelAdmin(Concert, self.site) cmafa = cma.get_form(request) self.assertEqual(type(cmafa.base_fields["main_band"].widget.widget), Select) self.assertEqual( list(cmafa.base_fields["main_band"].widget.choices), [("", "---------"), (self.band.id, "The Doors")], ) self.assertEqual(type(cmafa.base_fields["opening_band"].widget.widget), Select) self.assertEqual( list(cmafa.base_fields["opening_band"].widget.choices), [("", "---------"), (self.band.id, "The Doors")], ) self.assertEqual(type(cmafa.base_fields["day"].widget), Select) self.assertEqual( list(cmafa.base_fields["day"].widget.choices), [("", "---------"), (1, "Fri"), (2, "Sat")], ) self.assertEqual(type(cmafa.base_fields["transport"].widget), Select) self.assertEqual( list(cmafa.base_fields["transport"].widget.choices), [("", "---------"), (1, "Plane"), (2, "Train"), (3, "Bus")], ) def test_foreign_key_as_radio_field(self): # Now specify all the fields as radio_fields. Widgets should now be # RadioSelect, and the choices list should have a first entry of 'None' if # blank=True for the model field. Finally, the widget should have the # 'radiolist' attr, and 'inline' as well if the field is specified HORIZONTAL. class ConcertAdmin(ModelAdmin): radio_fields = { "main_band": HORIZONTAL, "opening_band": VERTICAL, "day": VERTICAL, "transport": HORIZONTAL, } cma = ConcertAdmin(Concert, self.site) cmafa = cma.get_form(request) self.assertEqual( type(cmafa.base_fields["main_band"].widget.widget), AdminRadioSelect ) self.assertEqual( cmafa.base_fields["main_band"].widget.attrs, {"class": "radiolist inline"} ) self.assertEqual( list(cmafa.base_fields["main_band"].widget.choices), [(self.band.id, "The Doors")], ) self.assertEqual( type(cmafa.base_fields["opening_band"].widget.widget), AdminRadioSelect ) self.assertEqual( cmafa.base_fields["opening_band"].widget.attrs, {"class": "radiolist"} ) self.assertEqual( list(cmafa.base_fields["opening_band"].widget.choices), [("", "None"), (self.band.id, "The Doors")], ) self.assertEqual(type(cmafa.base_fields["day"].widget), AdminRadioSelect) self.assertEqual(cmafa.base_fields["day"].widget.attrs, {"class": "radiolist"}) self.assertEqual( list(cmafa.base_fields["day"].widget.choices), [(1, "Fri"), (2, "Sat")] ) self.assertEqual(type(cmafa.base_fields["transport"].widget), AdminRadioSelect) self.assertEqual( cmafa.base_fields["transport"].widget.attrs, {"class": "radiolist inline"} ) self.assertEqual( list(cmafa.base_fields["transport"].widget.choices), [("", "None"), (1, "Plane"), (2, "Train"), (3, "Bus")], ) class AdminConcertForm(forms.ModelForm): class Meta: model = Concert exclude = ("transport",) class ConcertAdmin(ModelAdmin): form = AdminConcertForm ma = ConcertAdmin(Concert, self.site) self.assertEqual( list(ma.get_form(request).base_fields), ["main_band", "opening_band", "day"] ) class AdminConcertForm(forms.ModelForm): extra = forms.CharField() class Meta: model = Concert fields = ["extra", "transport"] class ConcertAdmin(ModelAdmin): form = AdminConcertForm ma = ConcertAdmin(Concert, self.site) self.assertEqual(list(ma.get_form(request).base_fields), ["extra", "transport"]) class ConcertInline(TabularInline): form = AdminConcertForm model = Concert fk_name = "main_band" can_delete = True class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, self.site) self.assertEqual( list(list(ma.get_formsets_with_inlines(request))[0][0]().forms[0].fields), ["extra", "transport", "id", "DELETE", "main_band"], ) def test_log_actions(self): ma = ModelAdmin(Band, self.site) mock_request = MockRequest() mock_request.user = User.objects.create(username="bill") content_type = get_content_type_for_model(self.band) tests = ( (ma.log_addition, ADDITION, {"added": {}}), (ma.log_change, CHANGE, {"changed": {"fields": ["name", "bio"]}}), (ma.log_deletion, DELETION, str(self.band)), ) for method, flag, message in tests: with self.subTest(name=method.__name__): created = method(mock_request, self.band, message) fetched = LogEntry.objects.filter(action_flag=flag).latest("id") self.assertEqual(created, fetched) self.assertEqual(fetched.action_flag, flag) self.assertEqual(fetched.content_type, content_type) self.assertEqual(fetched.object_id, str(self.band.pk)) self.assertEqual(fetched.user, mock_request.user) if flag == DELETION: self.assertEqual(fetched.change_message, "") self.assertEqual(fetched.object_repr, message) else: self.assertEqual(fetched.change_message, str(message)) self.assertEqual(fetched.object_repr, str(self.band)) def test_get_autocomplete_fields(self): class NameAdmin(ModelAdmin): search_fields = ["name"] class SongAdmin(ModelAdmin): autocomplete_fields = ["featuring"] fields = ["featuring", "band"] class OtherSongAdmin(SongAdmin): def get_autocomplete_fields(self, request): return ["band"] self.site.register(Band, NameAdmin) try: # Uses autocomplete_fields if not overridden. model_admin = SongAdmin(Song, self.site) form = model_admin.get_form(request)() self.assertIsInstance( form.fields["featuring"].widget.widget, AutocompleteSelectMultiple ) # Uses overridden get_autocomplete_fields model_admin = OtherSongAdmin(Song, self.site) form = model_admin.get_form(request)() self.assertIsInstance(form.fields["band"].widget.widget, AutocompleteSelect) finally: self.site.unregister(Band) def test_get_deleted_objects(self): mock_request = MockRequest() mock_request.user = User.objects.create_superuser( username="bob", email="[email protected]", password="test" ) self.site.register(Band, ModelAdmin) ma = self.site._registry[Band] ( deletable_objects, model_count, perms_needed, protected, ) = ma.get_deleted_objects([self.band], request) self.assertEqual(deletable_objects, ["Band: The Doors"]) self.assertEqual(model_count, {"bands": 1}) self.assertEqual(perms_needed, set()) self.assertEqual(protected, []) def test_get_deleted_objects_with_custom_has_delete_permission(self): """ ModelAdmin.get_deleted_objects() uses ModelAdmin.has_delete_permission() for permissions checking. """ mock_request = MockRequest() mock_request.user = User.objects.create_superuser( username="bob", email="[email protected]", password="test" ) class TestModelAdmin(ModelAdmin): def has_delete_permission(self, request, obj=None): return False self.site.register(Band, TestModelAdmin) ma = self.site._registry[Band] ( deletable_objects, model_count, perms_needed, protected, ) = ma.get_deleted_objects([self.band], request) self.assertEqual(deletable_objects, ["Band: The Doors"]) self.assertEqual(model_count, {"bands": 1}) self.assertEqual(perms_needed, {"band"}) self.assertEqual(protected, []) def test_modeladmin_repr(self): ma = ModelAdmin(Band, self.site) self.assertEqual( repr(ma), "<ModelAdmin: model=Band site=AdminSite(name='admin')>", ) class ModelAdminPermissionTests(SimpleTestCase): class MockUser: def has_module_perms(self, app_label): return app_label == "modeladmin" class MockViewUser(MockUser): def has_perm(self, perm, obj=None): return perm == "modeladmin.view_band" class MockAddUser(MockUser): def has_perm(self, perm, obj=None): return perm == "modeladmin.add_band" class MockChangeUser(MockUser): def has_perm(self, perm, obj=None): return perm == "modeladmin.change_band" class MockDeleteUser(MockUser): def has_perm(self, perm, obj=None): return perm == "modeladmin.delete_band" def test_has_view_permission(self): """ has_view_permission() returns True for users who can view objects and False for users who can't. """ ma = ModelAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockViewUser() self.assertIs(ma.has_view_permission(request), True) request.user = self.MockAddUser() self.assertIs(ma.has_view_permission(request), False) request.user = self.MockChangeUser() self.assertIs(ma.has_view_permission(request), True) request.user = self.MockDeleteUser() self.assertIs(ma.has_view_permission(request), False) def test_has_add_permission(self): """ has_add_permission returns True for users who can add objects and False for users who can't. """ ma = ModelAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockViewUser() self.assertFalse(ma.has_add_permission(request)) request.user = self.MockAddUser() self.assertTrue(ma.has_add_permission(request)) request.user = self.MockChangeUser() self.assertFalse(ma.has_add_permission(request)) request.user = self.MockDeleteUser() self.assertFalse(ma.has_add_permission(request)) def test_inline_has_add_permission_uses_obj(self): class ConcertInline(TabularInline): model = Concert def has_add_permission(self, request, obj): return bool(obj) class BandAdmin(ModelAdmin): inlines = [ConcertInline] ma = BandAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockAddUser() self.assertEqual(ma.get_inline_instances(request), []) band = Band(name="The Doors", bio="", sign_date=date(1965, 1, 1)) inline_instances = ma.get_inline_instances(request, band) self.assertEqual(len(inline_instances), 1) self.assertIsInstance(inline_instances[0], ConcertInline) def test_has_change_permission(self): """ has_change_permission returns True for users who can edit objects and False for users who can't. """ ma = ModelAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockViewUser() self.assertIs(ma.has_change_permission(request), False) request.user = self.MockAddUser() self.assertFalse(ma.has_change_permission(request)) request.user = self.MockChangeUser() self.assertTrue(ma.has_change_permission(request)) request.user = self.MockDeleteUser() self.assertFalse(ma.has_change_permission(request)) def test_has_delete_permission(self): """ has_delete_permission returns True for users who can delete objects and False for users who can't. """ ma = ModelAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockViewUser() self.assertIs(ma.has_delete_permission(request), False) request.user = self.MockAddUser() self.assertFalse(ma.has_delete_permission(request)) request.user = self.MockChangeUser() self.assertFalse(ma.has_delete_permission(request)) request.user = self.MockDeleteUser() self.assertTrue(ma.has_delete_permission(request)) def test_has_module_permission(self): """ as_module_permission returns True for users who have any permission for the module and False for users who don't. """ ma = ModelAdmin(Band, AdminSite()) request = MockRequest() request.user = self.MockViewUser() self.assertIs(ma.has_module_permission(request), True) request.user = self.MockAddUser() self.assertTrue(ma.has_module_permission(request)) request.user = self.MockChangeUser() self.assertTrue(ma.has_module_permission(request)) request.user = self.MockDeleteUser() self.assertTrue(ma.has_module_permission(request)) original_app_label = ma.opts.app_label ma.opts.app_label = "anotherapp" try: request.user = self.MockViewUser() self.assertIs(ma.has_module_permission(request), False) request.user = self.MockAddUser() self.assertFalse(ma.has_module_permission(request)) request.user = self.MockChangeUser() self.assertFalse(ma.has_module_permission(request)) request.user = self.MockDeleteUser() self.assertFalse(ma.has_module_permission(request)) finally: ma.opts.app_label = original_app_label
40382418910f94dc45e5899597883d9121a600923112fc6481ea698363013850
from django.contrib.auth.models import User from django.db import models class Band(models.Model): name = models.CharField(max_length=100) bio = models.TextField() sign_date = models.DateField() class Meta: ordering = ("name",) def __str__(self): return self.name class Song(models.Model): name = models.CharField(max_length=100) band = models.ForeignKey(Band, models.CASCADE) featuring = models.ManyToManyField(Band, related_name="featured") def __str__(self): return self.name class Concert(models.Model): main_band = models.ForeignKey(Band, models.CASCADE, related_name="main_concerts") opening_band = models.ForeignKey( Band, models.CASCADE, related_name="opening_concerts", blank=True ) day = models.CharField(max_length=3, choices=((1, "Fri"), (2, "Sat"))) transport = models.CharField( max_length=100, choices=((1, "Plane"), (2, "Train"), (3, "Bus")), blank=True ) class ValidationTestModel(models.Model): name = models.CharField(max_length=100) slug = models.SlugField() users = models.ManyToManyField(User) state = models.CharField( max_length=2, choices=(("CO", "Colorado"), ("WA", "Washington")) ) is_active = models.BooleanField(default=False) pub_date = models.DateTimeField() band = models.ForeignKey(Band, models.CASCADE) best_friend = models.OneToOneField(User, models.CASCADE, related_name="best_friend") # This field is intentionally 2 characters long (#16080). no = models.IntegerField(verbose_name="Number", blank=True, null=True) def decade_published_in(self): return self.pub_date.strftime("%Y")[:3] + "0's" class ValidationTestInlineModel(models.Model): parent = models.ForeignKey(ValidationTestModel, models.CASCADE)
9db2de738cc7fa9ef0ce9f482a7575f1db815fa1464d825ccf0f07979ad688f0
from django.contrib import admin from django.contrib.auth.models import Permission, User from django.contrib.contenttypes.models import ContentType from django.test import TestCase from .models import Band class AdminActionsTests(TestCase): @classmethod def setUpTestData(cls): cls.superuser = User.objects.create_superuser( username="super", password="secret", email="[email protected]" ) content_type = ContentType.objects.get_for_model(Band) Permission.objects.create( name="custom", codename="custom_band", content_type=content_type ) for user_type in ("view", "add", "change", "delete", "custom"): username = "%suser" % user_type user = User.objects.create_user( username=username, password="secret", is_staff=True ) permission = Permission.objects.get( codename="%s_band" % user_type, content_type=content_type ) user.user_permissions.add(permission) setattr(cls, username, user) def test_get_actions_respects_permissions(self): class MockRequest: pass class BandAdmin(admin.ModelAdmin): actions = ["custom_action"] @admin.action def custom_action(modeladmin, request, queryset): pass def has_custom_permission(self, request): return request.user.has_perm("%s.custom_band" % self.opts.app_label) ma = BandAdmin(Band, admin.AdminSite()) mock_request = MockRequest() mock_request.GET = {} cases = [ (None, self.viewuser, ["custom_action"]), ("view", self.superuser, ["delete_selected", "custom_action"]), ("view", self.viewuser, ["custom_action"]), ("add", self.adduser, ["custom_action"]), ("change", self.changeuser, ["custom_action"]), ("delete", self.deleteuser, ["delete_selected", "custom_action"]), ("custom", self.customuser, ["custom_action"]), ] for permission, user, expected in cases: with self.subTest(permission=permission, user=user): if permission is None: if hasattr(BandAdmin.custom_action, "allowed_permissions"): del BandAdmin.custom_action.allowed_permissions else: BandAdmin.custom_action.allowed_permissions = (permission,) mock_request.user = user actions = ma.get_actions(mock_request) self.assertEqual(list(actions.keys()), expected) def test_actions_inheritance(self): class AdminBase(admin.ModelAdmin): actions = ["custom_action"] @admin.action def custom_action(modeladmin, request, queryset): pass class AdminA(AdminBase): pass class AdminB(AdminBase): actions = None ma1 = AdminA(Band, admin.AdminSite()) action_names = [name for _, name, _ in ma1._get_base_actions()] self.assertEqual(action_names, ["delete_selected", "custom_action"]) # `actions = None` removes actions from superclasses. ma2 = AdminB(Band, admin.AdminSite()) action_names = [name for _, name, _ in ma2._get_base_actions()] self.assertEqual(action_names, ["delete_selected"]) def test_global_actions_description(self): @admin.action(description="Site-wide admin action 1.") def global_action_1(modeladmin, request, queryset): pass @admin.action def global_action_2(modeladmin, request, queryset): pass admin_site = admin.AdminSite() admin_site.add_action(global_action_1) admin_site.add_action(global_action_2) class BandAdmin(admin.ModelAdmin): pass ma = BandAdmin(Band, admin_site) self.assertEqual( [description for _, _, description in ma._get_base_actions()], [ "Delete selected %(verbose_name_plural)s", "Site-wide admin action 1.", "Global action 2", ], ) def test_actions_replace_global_action(self): @admin.action(description="Site-wide admin action 1.") def global_action_1(modeladmin, request, queryset): pass @admin.action(description="Site-wide admin action 2.") def global_action_2(modeladmin, request, queryset): pass admin.site.add_action(global_action_1, name="custom_action_1") admin.site.add_action(global_action_2, name="custom_action_2") @admin.action(description="Local admin action 1.") def custom_action_1(modeladmin, request, queryset): pass class BandAdmin(admin.ModelAdmin): actions = [custom_action_1, "custom_action_2"] @admin.action(description="Local admin action 2.") def custom_action_2(self, request, queryset): pass ma = BandAdmin(Band, admin.site) self.assertEqual(ma.check(), []) self.assertEqual( [ desc for _, name, desc in ma._get_base_actions() if name.startswith("custom_action") ], [ "Local admin action 1.", "Local admin action 2.", ], )
b106b8d91fe2d9ae2f23d9a63d0f36cb5401e75d546471553e232cb7d0a5df24
from django import forms from django.contrib import admin from django.contrib.admin import BooleanFieldListFilter, SimpleListFilter from django.contrib.admin.options import VERTICAL, ModelAdmin, TabularInline from django.contrib.admin.sites import AdminSite from django.core.checks import Error from django.db.models import CASCADE, F, Field, ForeignKey, Model from django.db.models.functions import Upper from django.forms.models import BaseModelFormSet from django.test import SimpleTestCase from .models import Band, Song, User, ValidationTestInlineModel, ValidationTestModel class CheckTestCase(SimpleTestCase): def assertIsInvalid( self, model_admin, model, msg, id=None, hint=None, invalid_obj=None, admin_site=None, ): if admin_site is None: admin_site = AdminSite() invalid_obj = invalid_obj or model_admin admin_obj = model_admin(model, admin_site) self.assertEqual( admin_obj.check(), [Error(msg, hint=hint, obj=invalid_obj, id=id)] ) def assertIsInvalidRegexp( self, model_admin, model, msg, id=None, hint=None, invalid_obj=None ): """ Same as assertIsInvalid but treats the given msg as a regexp. """ invalid_obj = invalid_obj or model_admin admin_obj = model_admin(model, AdminSite()) errors = admin_obj.check() self.assertEqual(len(errors), 1) error = errors[0] self.assertEqual(error.hint, hint) self.assertEqual(error.obj, invalid_obj) self.assertEqual(error.id, id) self.assertRegex(error.msg, msg) def assertIsValid(self, model_admin, model, admin_site=None): if admin_site is None: admin_site = AdminSite() admin_obj = model_admin(model, admin_site) self.assertEqual(admin_obj.check(), []) class RawIdCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): raw_id_fields = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'raw_id_fields' must be a list or tuple.", "admin.E001", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): raw_id_fields = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'raw_id_fields[0]' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E002", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): raw_id_fields = ("name",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'raw_id_fields[0]' must be a foreign key or a " "many-to-many field.", "admin.E003", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): raw_id_fields = ("users",) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_field_attname(self): class TestModelAdmin(ModelAdmin): raw_id_fields = ["band_id"] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'raw_id_fields[0]' refers to 'band_id', which is " "not a field of 'modeladmin.ValidationTestModel'.", "admin.E002", ) class FieldsetsCheckTests(CheckTestCase): def test_valid_case(self): class TestModelAdmin(ModelAdmin): fieldsets = (("General", {"fields": ("name",)}),) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_not_iterable(self): class TestModelAdmin(ModelAdmin): fieldsets = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fieldsets' must be a list or tuple.", "admin.E007", ) def test_non_iterable_item(self): class TestModelAdmin(ModelAdmin): fieldsets = ({},) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fieldsets[0]' must be a list or tuple.", "admin.E008", ) def test_item_not_a_pair(self): class TestModelAdmin(ModelAdmin): fieldsets = ((),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fieldsets[0]' must be of length 2.", "admin.E009", ) def test_second_element_of_item_not_a_dict(self): class TestModelAdmin(ModelAdmin): fieldsets = (("General", ()),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fieldsets[0][1]' must be a dictionary.", "admin.E010", ) def test_missing_fields_key(self): class TestModelAdmin(ModelAdmin): fieldsets = (("General", {}),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fieldsets[0][1]' must contain the key 'fields'.", "admin.E011", ) class TestModelAdmin(ModelAdmin): fieldsets = (("General", {"fields": ("name",)}),) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_specified_both_fields_and_fieldsets(self): class TestModelAdmin(ModelAdmin): fieldsets = (("General", {"fields": ("name",)}),) fields = ["name"] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "Both 'fieldsets' and 'fields' are specified.", "admin.E005", ) def test_duplicate_fields(self): class TestModelAdmin(ModelAdmin): fieldsets = [(None, {"fields": ["name", "name"]})] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "There are duplicate field(s) in 'fieldsets[0][1]'.", "admin.E012", ) def test_duplicate_fields_in_fieldsets(self): class TestModelAdmin(ModelAdmin): fieldsets = [ (None, {"fields": ["name"]}), (None, {"fields": ["name"]}), ] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "There are duplicate field(s) in 'fieldsets[1][1]'.", "admin.E012", ) def test_fieldsets_with_custom_form_validation(self): class BandAdmin(ModelAdmin): fieldsets = (("Band", {"fields": ("name",)}),) self.assertIsValid(BandAdmin, Band) class FieldsCheckTests(CheckTestCase): def test_duplicate_fields_in_fields(self): class TestModelAdmin(ModelAdmin): fields = ["name", "name"] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fields' contains duplicate field(s).", "admin.E006", ) def test_inline(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel fields = 10 class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'fields' must be a list or tuple.", "admin.E004", invalid_obj=ValidationTestInline, ) class FormCheckTests(CheckTestCase): def test_invalid_type(self): class FakeForm: pass class TestModelAdmin(ModelAdmin): form = FakeForm class TestModelAdminWithNoForm(ModelAdmin): form = "not a form" for model_admin in (TestModelAdmin, TestModelAdminWithNoForm): with self.subTest(model_admin): self.assertIsInvalid( model_admin, ValidationTestModel, "The value of 'form' must inherit from 'BaseModelForm'.", "admin.E016", ) def test_fieldsets_with_custom_form_validation(self): class BandAdmin(ModelAdmin): fieldsets = (("Band", {"fields": ("name",)}),) self.assertIsValid(BandAdmin, Band) def test_valid_case(self): class AdminBandForm(forms.ModelForm): delete = forms.BooleanField() class BandAdmin(ModelAdmin): form = AdminBandForm fieldsets = (("Band", {"fields": ("name", "bio", "sign_date", "delete")}),) self.assertIsValid(BandAdmin, Band) class FilterVerticalCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): filter_vertical = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_vertical' must be a list or tuple.", "admin.E017", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): filter_vertical = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_vertical[0]' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E019", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): filter_vertical = ("name",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_vertical[0]' must be a many-to-many field.", "admin.E020", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): filter_vertical = ("users",) self.assertIsValid(TestModelAdmin, ValidationTestModel) class FilterHorizontalCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): filter_horizontal = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_horizontal' must be a list or tuple.", "admin.E018", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): filter_horizontal = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_horizontal[0]' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E019", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): filter_horizontal = ("name",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'filter_horizontal[0]' must be a many-to-many field.", "admin.E020", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): filter_horizontal = ("users",) self.assertIsValid(TestModelAdmin, ValidationTestModel) class RadioFieldsCheckTests(CheckTestCase): def test_not_dictionary(self): class TestModelAdmin(ModelAdmin): radio_fields = () self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'radio_fields' must be a dictionary.", "admin.E021", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): radio_fields = {"non_existent_field": VERTICAL} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'radio_fields' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E022", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): radio_fields = {"name": VERTICAL} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'radio_fields' refers to 'name', which is not an instance " "of ForeignKey, and does not have a 'choices' definition.", "admin.E023", ) def test_invalid_value(self): class TestModelAdmin(ModelAdmin): radio_fields = {"state": None} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'radio_fields[\"state\"]' must be either admin.HORIZONTAL or " "admin.VERTICAL.", "admin.E024", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): radio_fields = {"state": VERTICAL} self.assertIsValid(TestModelAdmin, ValidationTestModel) class PrepopulatedFieldsCheckTests(CheckTestCase): def test_not_list_or_tuple(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"slug": "test"} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields[\"slug\"]' must be a list or tuple.", "admin.E029", ) def test_not_dictionary(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = () self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields' must be a dictionary.", "admin.E026", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"non_existent_field": ("slug",)} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E027", ) def test_missing_field_again(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"slug": ("non_existent_field",)} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields[\"slug\"][0]' refers to " "'non_existent_field', which is not a field of " "'modeladmin.ValidationTestModel'.", "admin.E030", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"users": ("name",)} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields' refers to 'users', which must not be " "a DateTimeField, a ForeignKey, a OneToOneField, or a ManyToManyField.", "admin.E028", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"slug": ("name",)} self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_one_to_one_field(self): class TestModelAdmin(ModelAdmin): prepopulated_fields = {"best_friend": ("name",)} self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'prepopulated_fields' refers to 'best_friend', which must " "not be a DateTimeField, a ForeignKey, a OneToOneField, or a " "ManyToManyField.", "admin.E028", ) class ListDisplayTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): list_display = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display' must be a list or tuple.", "admin.E107", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): list_display = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display[0]' refers to 'non_existent_field', " "which is not a callable, an attribute of 'TestModelAdmin', " "or an attribute or method on 'modeladmin.ValidationTestModel'.", "admin.E108", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): list_display = ("users",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display[0]' must not be a ManyToManyField.", "admin.E109", ) def test_valid_case(self): @admin.display def a_callable(obj): pass class TestModelAdmin(ModelAdmin): @admin.display def a_method(self, obj): pass list_display = ("name", "decade_published_in", "a_method", a_callable) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_valid_field_accessible_via_instance(self): class PositionField(Field): """Custom field accessible only via instance.""" def contribute_to_class(self, cls, name): super().contribute_to_class(cls, name) setattr(cls, self.name, self) def __get__(self, instance, owner): if instance is None: raise AttributeError() class TestModel(Model): field = PositionField() class TestModelAdmin(ModelAdmin): list_display = ("field",) self.assertIsValid(TestModelAdmin, TestModel) class ListDisplayLinksCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): list_display_links = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display_links' must be a list, a tuple, or None.", "admin.E110", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): list_display_links = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, ( "The value of 'list_display_links[0]' refers to " "'non_existent_field', which is not defined in 'list_display'." ), "admin.E111", ) def test_missing_in_list_display(self): class TestModelAdmin(ModelAdmin): list_display_links = ("name",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display_links[0]' refers to 'name', which is not " "defined in 'list_display'.", "admin.E111", ) def test_valid_case(self): @admin.display def a_callable(obj): pass class TestModelAdmin(ModelAdmin): @admin.display def a_method(self, obj): pass list_display = ("name", "decade_published_in", "a_method", a_callable) list_display_links = ("name", "decade_published_in", "a_method", a_callable) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_None_is_valid_case(self): class TestModelAdmin(ModelAdmin): list_display_links = None self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_list_display_links_check_skipped_if_get_list_display_overridden(self): """ list_display_links check is skipped if get_list_display() is overridden. """ class TestModelAdmin(ModelAdmin): list_display_links = ["name", "subtitle"] def get_list_display(self, request): pass self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_list_display_link_checked_for_list_tuple_if_get_list_display_overridden( self, ): """ list_display_links is checked for list/tuple/None even if get_list_display() is overridden. """ class TestModelAdmin(ModelAdmin): list_display_links = "non-list/tuple" def get_list_display(self, request): pass self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_display_links' must be a list, a tuple, or None.", "admin.E110", ) class ListFilterTests(CheckTestCase): def test_list_filter_validation(self): class TestModelAdmin(ModelAdmin): list_filter = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter' must be a list or tuple.", "admin.E112", ) def test_not_list_filter_class(self): class TestModelAdmin(ModelAdmin): list_filter = ["RandomClass"] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' refers to 'RandomClass', which " "does not refer to a Field.", "admin.E116", ) def test_callable(self): def random_callable(): pass class TestModelAdmin(ModelAdmin): list_filter = [random_callable] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' must inherit from 'ListFilter'.", "admin.E113", ) def test_not_callable(self): class TestModelAdmin(ModelAdmin): list_filter = [[42, 42]] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.", "admin.E115", ) def test_missing_field(self): class TestModelAdmin(ModelAdmin): list_filter = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' refers to 'non_existent_field', " "which does not refer to a Field.", "admin.E116", ) def test_not_filter(self): class RandomClass: pass class TestModelAdmin(ModelAdmin): list_filter = (RandomClass,) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' must inherit from 'ListFilter'.", "admin.E113", ) def test_not_filter_again(self): class RandomClass: pass class TestModelAdmin(ModelAdmin): list_filter = (("is_active", RandomClass),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.", "admin.E115", ) def test_not_filter_again_again(self): class AwesomeFilter(SimpleListFilter): def get_title(self): return "awesomeness" def get_choices(self, request): return (("bit", "A bit awesome"), ("very", "Very awesome")) def get_queryset(self, cl, qs): return qs class TestModelAdmin(ModelAdmin): list_filter = (("is_active", AwesomeFilter),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0][1]' must inherit from 'FieldListFilter'.", "admin.E115", ) def test_list_filter_is_func(self): def get_filter(): pass class TestModelAdmin(ModelAdmin): list_filter = [get_filter] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' must inherit from 'ListFilter'.", "admin.E113", ) def test_not_associated_with_field_name(self): class TestModelAdmin(ModelAdmin): list_filter = (BooleanFieldListFilter,) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_filter[0]' must not inherit from 'FieldListFilter'.", "admin.E114", ) def test_valid_case(self): class AwesomeFilter(SimpleListFilter): def get_title(self): return "awesomeness" def get_choices(self, request): return (("bit", "A bit awesome"), ("very", "Very awesome")) def get_queryset(self, cl, qs): return qs class TestModelAdmin(ModelAdmin): list_filter = ( "is_active", AwesomeFilter, ("is_active", BooleanFieldListFilter), "no", ) self.assertIsValid(TestModelAdmin, ValidationTestModel) class ListPerPageCheckTests(CheckTestCase): def test_not_integer(self): class TestModelAdmin(ModelAdmin): list_per_page = "hello" self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_per_page' must be an integer.", "admin.E118", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): list_per_page = 100 self.assertIsValid(TestModelAdmin, ValidationTestModel) class ListMaxShowAllCheckTests(CheckTestCase): def test_not_integer(self): class TestModelAdmin(ModelAdmin): list_max_show_all = "hello" self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_max_show_all' must be an integer.", "admin.E119", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): list_max_show_all = 200 self.assertIsValid(TestModelAdmin, ValidationTestModel) class SearchFieldsCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): search_fields = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'search_fields' must be a list or tuple.", "admin.E126", ) class DateHierarchyCheckTests(CheckTestCase): def test_missing_field(self): class TestModelAdmin(ModelAdmin): date_hierarchy = "non_existent_field" self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'date_hierarchy' refers to 'non_existent_field', " "which does not refer to a Field.", "admin.E127", ) def test_invalid_field_type(self): class TestModelAdmin(ModelAdmin): date_hierarchy = "name" self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'date_hierarchy' must be a DateField or DateTimeField.", "admin.E128", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): date_hierarchy = "pub_date" self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_related_valid_case(self): class TestModelAdmin(ModelAdmin): date_hierarchy = "band__sign_date" self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_related_invalid_field_type(self): class TestModelAdmin(ModelAdmin): date_hierarchy = "band__name" self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'date_hierarchy' must be a DateField or DateTimeField.", "admin.E128", ) class OrderingCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): ordering = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'ordering' must be a list or tuple.", "admin.E031", ) class TestModelAdmin(ModelAdmin): ordering = ("non_existent_field",) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'ordering[0]' refers to 'non_existent_field', " "which is not a field of 'modeladmin.ValidationTestModel'.", "admin.E033", ) def test_random_marker_not_alone(self): class TestModelAdmin(ModelAdmin): ordering = ("?", "name") self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'ordering' has the random ordering marker '?', but contains " "other fields as well.", "admin.E032", hint='Either remove the "?", or remove the other fields.', ) def test_valid_random_marker_case(self): class TestModelAdmin(ModelAdmin): ordering = ("?",) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_valid_complex_case(self): class TestModelAdmin(ModelAdmin): ordering = ("band__name",) self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_valid_case(self): class TestModelAdmin(ModelAdmin): ordering = ("name", "pk") self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_invalid_expression(self): class TestModelAdmin(ModelAdmin): ordering = (F("nonexistent"),) self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'ordering[0]' refers to 'nonexistent', which is not " "a field of 'modeladmin.ValidationTestModel'.", "admin.E033", ) def test_valid_expression(self): class TestModelAdmin(ModelAdmin): ordering = (Upper("name"), Upper("band__name").desc()) self.assertIsValid(TestModelAdmin, ValidationTestModel) class ListSelectRelatedCheckTests(CheckTestCase): def test_invalid_type(self): class TestModelAdmin(ModelAdmin): list_select_related = 1 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'list_select_related' must be a boolean, tuple or list.", "admin.E117", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): list_select_related = False self.assertIsValid(TestModelAdmin, ValidationTestModel) class SaveAsCheckTests(CheckTestCase): def test_not_boolean(self): class TestModelAdmin(ModelAdmin): save_as = 1 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'save_as' must be a boolean.", "admin.E101", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): save_as = True self.assertIsValid(TestModelAdmin, ValidationTestModel) class SaveOnTopCheckTests(CheckTestCase): def test_not_boolean(self): class TestModelAdmin(ModelAdmin): save_on_top = 1 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'save_on_top' must be a boolean.", "admin.E102", ) def test_valid_case(self): class TestModelAdmin(ModelAdmin): save_on_top = True self.assertIsValid(TestModelAdmin, ValidationTestModel) class InlinesCheckTests(CheckTestCase): def test_not_iterable(self): class TestModelAdmin(ModelAdmin): inlines = 10 self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'inlines' must be a list or tuple.", "admin.E103", ) def test_not_correct_inline_field(self): class TestModelAdmin(ModelAdmin): inlines = [42] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"'.*\.TestModelAdmin' must inherit from 'InlineModelAdmin'\.", "admin.E104", ) def test_not_model_admin(self): class ValidationTestInline: pass class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"'.*\.ValidationTestInline' must inherit from 'InlineModelAdmin'\.", "admin.E104", ) def test_missing_model_field(self): class ValidationTestInline(TabularInline): pass class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"'.*\.ValidationTestInline' must have a 'model' attribute\.", "admin.E105", ) def test_invalid_model_type(self): class SomethingBad: pass class ValidationTestInline(TabularInline): model = SomethingBad class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"The value of '.*\.ValidationTestInline.model' must be a Model\.", "admin.E106", ) def test_invalid_model(self): class ValidationTestInline(TabularInline): model = "Not a class" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"The value of '.*\.ValidationTestInline.model' must be a Model\.", "admin.E106", ) def test_invalid_callable(self): def random_obj(): pass class TestModelAdmin(ModelAdmin): inlines = [random_obj] self.assertIsInvalidRegexp( TestModelAdmin, ValidationTestModel, r"'.*\.random_obj' must inherit from 'InlineModelAdmin'\.", "admin.E104", ) def test_valid_case(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) class FkNameCheckTests(CheckTestCase): def test_missing_field(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel fk_name = "non_existent_field" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "'modeladmin.ValidationTestInlineModel' has no field named " "'non_existent_field'.", "admin.E202", invalid_obj=ValidationTestInline, ) def test_valid_case(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel fk_name = "parent" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) def test_proxy_model_parent(self): class Parent(Model): pass class ProxyChild(Parent): class Meta: proxy = True class ProxyProxyChild(ProxyChild): class Meta: proxy = True class Related(Model): proxy_child = ForeignKey(ProxyChild, on_delete=CASCADE) class InlineFkName(admin.TabularInline): model = Related fk_name = "proxy_child" class InlineNoFkName(admin.TabularInline): model = Related class ProxyProxyChildAdminFkName(admin.ModelAdmin): inlines = [InlineFkName, InlineNoFkName] self.assertIsValid(ProxyProxyChildAdminFkName, ProxyProxyChild) class ExtraCheckTests(CheckTestCase): def test_not_integer(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel extra = "hello" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'extra' must be an integer.", "admin.E203", invalid_obj=ValidationTestInline, ) def test_valid_case(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel extra = 2 class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) class MaxNumCheckTests(CheckTestCase): def test_not_integer(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel max_num = "hello" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'max_num' must be an integer.", "admin.E204", invalid_obj=ValidationTestInline, ) def test_valid_case(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel max_num = 2 class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) class MinNumCheckTests(CheckTestCase): def test_not_integer(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel min_num = "hello" class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'min_num' must be an integer.", "admin.E205", invalid_obj=ValidationTestInline, ) def test_valid_case(self): class ValidationTestInline(TabularInline): model = ValidationTestInlineModel min_num = 2 class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) class FormsetCheckTests(CheckTestCase): def test_invalid_type(self): class FakeFormSet: pass class ValidationTestInline(TabularInline): model = ValidationTestInlineModel formset = FakeFormSet class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsInvalid( TestModelAdmin, ValidationTestModel, "The value of 'formset' must inherit from 'BaseModelFormSet'.", "admin.E206", invalid_obj=ValidationTestInline, ) def test_inline_without_formset_class(self): class ValidationTestInlineWithoutFormsetClass(TabularInline): model = ValidationTestInlineModel formset = "Not a FormSet Class" class TestModelAdminWithoutFormsetClass(ModelAdmin): inlines = [ValidationTestInlineWithoutFormsetClass] self.assertIsInvalid( TestModelAdminWithoutFormsetClass, ValidationTestModel, "The value of 'formset' must inherit from 'BaseModelFormSet'.", "admin.E206", invalid_obj=ValidationTestInlineWithoutFormsetClass, ) def test_valid_case(self): class RealModelFormSet(BaseModelFormSet): pass class ValidationTestInline(TabularInline): model = ValidationTestInlineModel formset = RealModelFormSet class TestModelAdmin(ModelAdmin): inlines = [ValidationTestInline] self.assertIsValid(TestModelAdmin, ValidationTestModel) class ListDisplayEditableTests(CheckTestCase): def test_list_display_links_is_none(self): """ list_display and list_editable can contain the same values when list_display_links is None """ class ProductAdmin(ModelAdmin): list_display = ["name", "slug", "pub_date"] list_editable = list_display list_display_links = None self.assertIsValid(ProductAdmin, ValidationTestModel) def test_list_display_first_item_same_as_list_editable_first_item(self): """ The first item in list_display can be the same as the first in list_editable. """ class ProductAdmin(ModelAdmin): list_display = ["name", "slug", "pub_date"] list_editable = ["name", "slug"] list_display_links = ["pub_date"] self.assertIsValid(ProductAdmin, ValidationTestModel) def test_list_display_first_item_in_list_editable(self): """ The first item in list_display can be in list_editable as long as list_display_links is defined. """ class ProductAdmin(ModelAdmin): list_display = ["name", "slug", "pub_date"] list_editable = ["slug", "name"] list_display_links = ["pub_date"] self.assertIsValid(ProductAdmin, ValidationTestModel) def test_list_display_first_item_same_as_list_editable_no_list_display_links(self): """ The first item in list_display cannot be the same as the first item in list_editable if list_display_links is not defined. """ class ProductAdmin(ModelAdmin): list_display = ["name"] list_editable = ["name"] self.assertIsInvalid( ProductAdmin, ValidationTestModel, "The value of 'list_editable[0]' refers to the first field " "in 'list_display' ('name'), which cannot be used unless " "'list_display_links' is set.", id="admin.E124", ) def test_list_display_first_item_in_list_editable_no_list_display_links(self): """ The first item in list_display cannot be in list_editable if list_display_links isn't defined. """ class ProductAdmin(ModelAdmin): list_display = ["name", "slug", "pub_date"] list_editable = ["slug", "name"] self.assertIsInvalid( ProductAdmin, ValidationTestModel, "The value of 'list_editable[1]' refers to the first field " "in 'list_display' ('name'), which cannot be used unless " "'list_display_links' is set.", id="admin.E124", ) def test_both_list_editable_and_list_display_links(self): class ProductAdmin(ModelAdmin): list_editable = ("name",) list_display = ("name",) list_display_links = ("name",) self.assertIsInvalid( ProductAdmin, ValidationTestModel, "The value of 'name' cannot be in both 'list_editable' and " "'list_display_links'.", id="admin.E123", ) class AutocompleteFieldsTests(CheckTestCase): def test_autocomplete_e036(self): class Admin(ModelAdmin): autocomplete_fields = "name" self.assertIsInvalid( Admin, Band, msg="The value of 'autocomplete_fields' must be a list or tuple.", id="admin.E036", invalid_obj=Admin, ) def test_autocomplete_e037(self): class Admin(ModelAdmin): autocomplete_fields = ("nonexistent",) self.assertIsInvalid( Admin, ValidationTestModel, msg=( "The value of 'autocomplete_fields[0]' refers to 'nonexistent', " "which is not a field of 'modeladmin.ValidationTestModel'." ), id="admin.E037", invalid_obj=Admin, ) def test_autocomplete_e38(self): class Admin(ModelAdmin): autocomplete_fields = ("name",) self.assertIsInvalid( Admin, ValidationTestModel, msg=( "The value of 'autocomplete_fields[0]' must be a foreign " "key or a many-to-many field." ), id="admin.E038", invalid_obj=Admin, ) def test_autocomplete_e039(self): class Admin(ModelAdmin): autocomplete_fields = ("band",) self.assertIsInvalid( Admin, Song, msg=( 'An admin for model "Band" has to be registered ' "to be referenced by Admin.autocomplete_fields." ), id="admin.E039", invalid_obj=Admin, ) def test_autocomplete_e040(self): class NoSearchFieldsAdmin(ModelAdmin): pass class AutocompleteAdmin(ModelAdmin): autocomplete_fields = ("featuring",) site = AdminSite() site.register(Band, NoSearchFieldsAdmin) self.assertIsInvalid( AutocompleteAdmin, Song, msg=( 'NoSearchFieldsAdmin must define "search_fields", because ' "it's referenced by AutocompleteAdmin.autocomplete_fields." ), id="admin.E040", invalid_obj=AutocompleteAdmin, admin_site=site, ) def test_autocomplete_is_valid(self): class SearchFieldsAdmin(ModelAdmin): search_fields = "name" class AutocompleteAdmin(ModelAdmin): autocomplete_fields = ("featuring",) site = AdminSite() site.register(Band, SearchFieldsAdmin) self.assertIsValid(AutocompleteAdmin, Song, admin_site=site) def test_autocomplete_is_onetoone(self): class UserAdmin(ModelAdmin): search_fields = ("name",) class Admin(ModelAdmin): autocomplete_fields = ("best_friend",) site = AdminSite() site.register(User, UserAdmin) self.assertIsValid(Admin, ValidationTestModel, admin_site=site) class ActionsCheckTests(CheckTestCase): def test_custom_permissions_require_matching_has_method(self): @admin.action(permissions=["custom"]) def custom_permission_action(modeladmin, request, queryset): pass class BandAdmin(ModelAdmin): actions = (custom_permission_action,) self.assertIsInvalid( BandAdmin, Band, "BandAdmin must define a has_custom_permission() method for the " "custom_permission_action action.", id="admin.E129", ) def test_actions_not_unique(self): @admin.action def action(modeladmin, request, queryset): pass class BandAdmin(ModelAdmin): actions = (action, action) self.assertIsInvalid( BandAdmin, Band, "__name__ attributes of actions defined in BandAdmin must be " "unique. Name 'action' is not unique.", id="admin.E130", ) def test_actions_unique(self): @admin.action def action1(modeladmin, request, queryset): pass @admin.action def action2(modeladmin, request, queryset): pass class BandAdmin(ModelAdmin): actions = (action1, action2) self.assertIsValid(BandAdmin, Band)
71b01aba0dc1116f798dc40aabd7418b31585f8b870e708f5c6ea7232bc2c681
""" Tests for django test runner """ import collections.abc import multiprocessing import os import sys import unittest from unittest import mock from admin_scripts.tests import AdminScriptTestCase from django import db from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.core.management import call_command from django.core.management.base import SystemCheckError from django.test import SimpleTestCase, TransactionTestCase, skipUnlessDBFeature from django.test.runner import ( DiscoverRunner, Shuffler, reorder_test_bin, reorder_tests, shuffle_tests, ) from django.test.testcases import connections_support_transactions from django.test.utils import ( captured_stderr, dependency_ordered, get_unique_databases_and_mirrors, iter_test_cases, ) from django.utils.deprecation import RemovedInDjango50Warning from .models import B, Person, Through class MySuite: def __init__(self): self.tests = [] def addTest(self, test): self.tests.append(test) def __iter__(self): yield from self.tests class TestSuiteTests(SimpleTestCase): def build_test_suite(self, test_classes, suite=None, suite_class=None): if suite_class is None: suite_class = unittest.TestSuite if suite is None: suite = suite_class() loader = unittest.defaultTestLoader for test_class in test_classes: tests = loader.loadTestsFromTestCase(test_class) subsuite = suite_class() # Only use addTest() to simplify testing a custom TestSuite. for test in tests: subsuite.addTest(test) suite.addTest(subsuite) return suite def make_test_suite(self, suite=None, suite_class=None): class Tests1(unittest.TestCase): def test1(self): pass def test2(self): pass class Tests2(unittest.TestCase): def test1(self): pass def test2(self): pass return self.build_test_suite( (Tests1, Tests2), suite=suite, suite_class=suite_class, ) def assertTestNames(self, tests, expected): # Each test.id() has a form like the following: # "test_runner.tests.IterTestCasesTests.test_iter_test_cases.<locals>.Tests1.test1". # It suffices to check only the last two parts. names = [".".join(test.id().split(".")[-2:]) for test in tests] self.assertEqual(names, expected) def test_iter_test_cases_basic(self): suite = self.make_test_suite() tests = iter_test_cases(suite) self.assertTestNames( tests, expected=[ "Tests1.test1", "Tests1.test2", "Tests2.test1", "Tests2.test2", ], ) def test_iter_test_cases_string_input(self): msg = ( "Test 'a' must be a test case or test suite not string (was found " "in 'abc')." ) with self.assertRaisesMessage(TypeError, msg): list(iter_test_cases("abc")) def test_iter_test_cases_iterable_of_tests(self): class Tests(unittest.TestCase): def test1(self): pass def test2(self): pass tests = list(unittest.defaultTestLoader.loadTestsFromTestCase(Tests)) actual_tests = iter_test_cases(tests) self.assertTestNames( actual_tests, expected=[ "Tests.test1", "Tests.test2", ], ) def test_iter_test_cases_custom_test_suite_class(self): suite = self.make_test_suite(suite_class=MySuite) tests = iter_test_cases(suite) self.assertTestNames( tests, expected=[ "Tests1.test1", "Tests1.test2", "Tests2.test1", "Tests2.test2", ], ) def test_iter_test_cases_mixed_test_suite_classes(self): suite = self.make_test_suite(suite=MySuite()) child_suite = list(suite)[0] self.assertNotIsInstance(child_suite, MySuite) tests = list(iter_test_cases(suite)) self.assertEqual(len(tests), 4) self.assertNotIsInstance(tests[0], unittest.TestSuite) def make_tests(self): """Return an iterable of tests.""" suite = self.make_test_suite() tests = list(iter_test_cases(suite)) return tests def test_shuffle_tests(self): tests = self.make_tests() # Choose a seed that shuffles both the classes and methods. shuffler = Shuffler(seed=9) shuffled_tests = shuffle_tests(tests, shuffler) self.assertIsInstance(shuffled_tests, collections.abc.Iterator) self.assertTestNames( shuffled_tests, expected=[ "Tests2.test1", "Tests2.test2", "Tests1.test2", "Tests1.test1", ], ) def test_reorder_test_bin_no_arguments(self): tests = self.make_tests() reordered_tests = reorder_test_bin(tests) self.assertIsInstance(reordered_tests, collections.abc.Iterator) self.assertTestNames( reordered_tests, expected=[ "Tests1.test1", "Tests1.test2", "Tests2.test1", "Tests2.test2", ], ) def test_reorder_test_bin_reverse(self): tests = self.make_tests() reordered_tests = reorder_test_bin(tests, reverse=True) self.assertIsInstance(reordered_tests, collections.abc.Iterator) self.assertTestNames( reordered_tests, expected=[ "Tests2.test2", "Tests2.test1", "Tests1.test2", "Tests1.test1", ], ) def test_reorder_test_bin_random(self): tests = self.make_tests() # Choose a seed that shuffles both the classes and methods. shuffler = Shuffler(seed=9) reordered_tests = reorder_test_bin(tests, shuffler=shuffler) self.assertIsInstance(reordered_tests, collections.abc.Iterator) self.assertTestNames( reordered_tests, expected=[ "Tests2.test1", "Tests2.test2", "Tests1.test2", "Tests1.test1", ], ) def test_reorder_test_bin_random_and_reverse(self): tests = self.make_tests() # Choose a seed that shuffles both the classes and methods. shuffler = Shuffler(seed=9) reordered_tests = reorder_test_bin(tests, shuffler=shuffler, reverse=True) self.assertIsInstance(reordered_tests, collections.abc.Iterator) self.assertTestNames( reordered_tests, expected=[ "Tests1.test1", "Tests1.test2", "Tests2.test2", "Tests2.test1", ], ) def test_reorder_tests_same_type_consecutive(self): """Tests of the same type are made consecutive.""" tests = self.make_tests() # Move the last item to the front. tests.insert(0, tests.pop()) self.assertTestNames( tests, expected=[ "Tests2.test2", "Tests1.test1", "Tests1.test2", "Tests2.test1", ], ) reordered_tests = reorder_tests(tests, classes=[]) self.assertTestNames( reordered_tests, expected=[ "Tests2.test2", "Tests2.test1", "Tests1.test1", "Tests1.test2", ], ) def test_reorder_tests_random(self): tests = self.make_tests() # Choose a seed that shuffles both the classes and methods. shuffler = Shuffler(seed=9) reordered_tests = reorder_tests(tests, classes=[], shuffler=shuffler) self.assertIsInstance(reordered_tests, collections.abc.Iterator) self.assertTestNames( reordered_tests, expected=[ "Tests2.test1", "Tests2.test2", "Tests1.test2", "Tests1.test1", ], ) def test_reorder_tests_random_mixed_classes(self): tests = self.make_tests() # Move the last item to the front. tests.insert(0, tests.pop()) shuffler = Shuffler(seed=9) self.assertTestNames( tests, expected=[ "Tests2.test2", "Tests1.test1", "Tests1.test2", "Tests2.test1", ], ) reordered_tests = reorder_tests(tests, classes=[], shuffler=shuffler) self.assertTestNames( reordered_tests, expected=[ "Tests2.test1", "Tests2.test2", "Tests1.test2", "Tests1.test1", ], ) def test_reorder_tests_reverse_with_duplicates(self): class Tests1(unittest.TestCase): def test1(self): pass class Tests2(unittest.TestCase): def test2(self): pass def test3(self): pass suite = self.build_test_suite((Tests1, Tests2)) subsuite = list(suite)[0] suite.addTest(subsuite) tests = list(iter_test_cases(suite)) self.assertTestNames( tests, expected=[ "Tests1.test1", "Tests2.test2", "Tests2.test3", "Tests1.test1", ], ) reordered_tests = reorder_tests(tests, classes=[]) self.assertTestNames( reordered_tests, expected=[ "Tests1.test1", "Tests2.test2", "Tests2.test3", ], ) reordered_tests = reorder_tests(tests, classes=[], reverse=True) self.assertTestNames( reordered_tests, expected=[ "Tests2.test3", "Tests2.test2", "Tests1.test1", ], ) class DependencyOrderingTests(unittest.TestCase): def test_simple_dependencies(self): raw = [ ("s1", ("s1_db", ["alpha"])), ("s2", ("s2_db", ["bravo"])), ("s3", ("s3_db", ["charlie"])), ] dependencies = { "alpha": ["charlie"], "bravo": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, value in ordered] self.assertIn("s1", ordered_sigs) self.assertIn("s2", ordered_sigs) self.assertIn("s3", ordered_sigs) self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) def test_chained_dependencies(self): raw = [ ("s1", ("s1_db", ["alpha"])), ("s2", ("s2_db", ["bravo"])), ("s3", ("s3_db", ["charlie"])), ] dependencies = { "alpha": ["bravo"], "bravo": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, value in ordered] self.assertIn("s1", ordered_sigs) self.assertIn("s2", ordered_sigs) self.assertIn("s3", ordered_sigs) # Explicit dependencies self.assertLess(ordered_sigs.index("s2"), ordered_sigs.index("s1")) self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) # Implied dependencies self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) def test_multiple_dependencies(self): raw = [ ("s1", ("s1_db", ["alpha"])), ("s2", ("s2_db", ["bravo"])), ("s3", ("s3_db", ["charlie"])), ("s4", ("s4_db", ["delta"])), ] dependencies = { "alpha": ["bravo", "delta"], "bravo": ["charlie"], "delta": ["charlie"], } ordered = dependency_ordered(raw, dependencies=dependencies) ordered_sigs = [sig for sig, aliases in ordered] self.assertIn("s1", ordered_sigs) self.assertIn("s2", ordered_sigs) self.assertIn("s3", ordered_sigs) self.assertIn("s4", ordered_sigs) # Explicit dependencies self.assertLess(ordered_sigs.index("s2"), ordered_sigs.index("s1")) self.assertLess(ordered_sigs.index("s4"), ordered_sigs.index("s1")) self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s2")) self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s4")) # Implicit dependencies self.assertLess(ordered_sigs.index("s3"), ordered_sigs.index("s1")) def test_circular_dependencies(self): raw = [ ("s1", ("s1_db", ["alpha"])), ("s2", ("s2_db", ["bravo"])), ] dependencies = { "bravo": ["alpha"], "alpha": ["bravo"], } with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) def test_own_alias_dependency(self): raw = [("s1", ("s1_db", ["alpha", "bravo"]))] dependencies = {"alpha": ["bravo"]} with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) # reordering aliases shouldn't matter raw = [("s1", ("s1_db", ["bravo", "alpha"]))] with self.assertRaises(ImproperlyConfigured): dependency_ordered(raw, dependencies=dependencies) class MockTestRunner: def __init__(self, *args, **kwargs): if parallel := kwargs.get("parallel"): sys.stderr.write(f"parallel={parallel}") MockTestRunner.run_tests = mock.Mock(return_value=[]) class ManageCommandTests(unittest.TestCase): def test_custom_test_runner(self): call_command("test", "sites", testrunner="test_runner.tests.MockTestRunner") MockTestRunner.run_tests.assert_called_with(("sites",)) def test_bad_test_runner(self): with self.assertRaises(AttributeError): call_command("test", "sites", testrunner="test_runner.NonexistentRunner") def test_time_recorded(self): with captured_stderr() as stderr: call_command( "test", "--timing", "sites", testrunner="test_runner.tests.MockTestRunner", ) self.assertIn("Total run took", stderr.getvalue()) # Isolate from the real environment. @mock.patch.dict(os.environ, {}, clear=True) @mock.patch.object(multiprocessing, "cpu_count", return_value=12) # Python 3.8 on macOS defaults to 'spawn' mode. @mock.patch.object(multiprocessing, "get_start_method", return_value="fork") class ManageCommandParallelTests(SimpleTestCase): def test_parallel_default(self, *mocked_objects): with captured_stderr() as stderr: call_command( "test", "--parallel", testrunner="test_runner.tests.MockTestRunner", ) self.assertIn("parallel=12", stderr.getvalue()) def test_parallel_auto(self, *mocked_objects): with captured_stderr() as stderr: call_command( "test", "--parallel=auto", testrunner="test_runner.tests.MockTestRunner", ) self.assertIn("parallel=12", stderr.getvalue()) def test_no_parallel(self, *mocked_objects): with captured_stderr() as stderr: call_command("test", testrunner="test_runner.tests.MockTestRunner") # Parallel is disabled by default. self.assertEqual(stderr.getvalue(), "") def test_parallel_spawn(self, mocked_get_start_method, mocked_cpu_count): mocked_get_start_method.return_value = "spawn" with captured_stderr() as stderr: call_command( "test", "--parallel=auto", testrunner="test_runner.tests.MockTestRunner", ) self.assertIn("parallel=1", stderr.getvalue()) def test_no_parallel_spawn(self, mocked_get_start_method, mocked_cpu_count): mocked_get_start_method.return_value = "spawn" with captured_stderr() as stderr: call_command( "test", testrunner="test_runner.tests.MockTestRunner", ) self.assertEqual(stderr.getvalue(), "") @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}) def test_no_parallel_django_test_processes_env(self, *mocked_objects): with captured_stderr() as stderr: call_command("test", testrunner="test_runner.tests.MockTestRunner") self.assertEqual(stderr.getvalue(), "") @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "invalid"}) def test_django_test_processes_env_non_int(self, *mocked_objects): with self.assertRaises(ValueError): call_command( "test", "--parallel", testrunner="test_runner.tests.MockTestRunner", ) @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}) def test_django_test_processes_parallel_default(self, *mocked_objects): for parallel in ["--parallel", "--parallel=auto"]: with self.subTest(parallel=parallel): with captured_stderr() as stderr: call_command( "test", parallel, testrunner="test_runner.tests.MockTestRunner", ) self.assertIn("parallel=7", stderr.getvalue()) class CustomTestRunnerOptionsSettingsTests(AdminScriptTestCase): """ Custom runners can add command line arguments. The runner is specified through a settings file. """ def setUp(self): super().setUp() settings = { "TEST_RUNNER": "'test_runner.runner.CustomOptionsTestRunner'", } self.write_settings("settings.py", sdict=settings) def test_default_options(self): args = ["test", "--settings=test_project.settings"] out, err = self.run_django_admin(args) self.assertNoOutput(err) self.assertOutput(out, "1:2:3") def test_default_and_given_options(self): args = ["test", "--settings=test_project.settings", "--option_b=foo"] out, err = self.run_django_admin(args) self.assertNoOutput(err) self.assertOutput(out, "1:foo:3") def test_option_name_and_value_separated(self): args = ["test", "--settings=test_project.settings", "--option_b", "foo"] out, err = self.run_django_admin(args) self.assertNoOutput(err) self.assertOutput(out, "1:foo:3") def test_all_options_given(self): args = [ "test", "--settings=test_project.settings", "--option_a=bar", "--option_b=foo", "--option_c=31337", ] out, err = self.run_django_admin(args) self.assertNoOutput(err) self.assertOutput(out, "bar:foo:31337") class CustomTestRunnerOptionsCmdlineTests(AdminScriptTestCase): """ Custom runners can add command line arguments when the runner is specified using --testrunner. """ def setUp(self): super().setUp() self.write_settings("settings.py") def test_testrunner_option(self): args = [ "test", "--testrunner", "test_runner.runner.CustomOptionsTestRunner", "--option_a=bar", "--option_b=foo", "--option_c=31337", ] out, err = self.run_django_admin(args, "test_project.settings") self.assertNoOutput(err) self.assertOutput(out, "bar:foo:31337") def test_testrunner_equals(self): args = [ "test", "--testrunner=test_runner.runner.CustomOptionsTestRunner", "--option_a=bar", "--option_b=foo", "--option_c=31337", ] out, err = self.run_django_admin(args, "test_project.settings") self.assertNoOutput(err) self.assertOutput(out, "bar:foo:31337") def test_no_testrunner(self): args = ["test", "--testrunner"] out, err = self.run_django_admin(args, "test_project.settings") self.assertIn("usage", err) self.assertNotIn("Traceback", err) self.assertNoOutput(out) class Ticket17477RegressionTests(AdminScriptTestCase): def setUp(self): super().setUp() self.write_settings("settings.py") def test_ticket_17477(self): """'manage.py help test' works after r16352.""" args = ["help", "test"] out, err = self.run_manage(args) self.assertNoOutput(err) class SQLiteInMemoryTestDbs(TransactionTestCase): available_apps = ["test_runner"] databases = {"default", "other"} @unittest.skipUnless( all(db.connections[conn].vendor == "sqlite" for conn in db.connections), "This is an sqlite-specific issue", ) def test_transaction_support(self): # Assert connections mocking is appropriately applied by preventing # any attempts at calling create_test_db on the global connection # objects. for connection in db.connections.all(): create_test_db = mock.patch.object( connection.creation, "create_test_db", side_effect=AssertionError( "Global connection object shouldn't be manipulated." ), ) create_test_db.start() self.addCleanup(create_test_db.stop) for option_key, option_value in ( ("NAME", ":memory:"), ("TEST", {"NAME": ":memory:"}), ): tested_connections = db.ConnectionHandler( { "default": { "ENGINE": "django.db.backends.sqlite3", option_key: option_value, }, "other": { "ENGINE": "django.db.backends.sqlite3", option_key: option_value, }, } ) with mock.patch("django.test.utils.connections", new=tested_connections): other = tested_connections["other"] DiscoverRunner(verbosity=0).setup_databases() msg = ( "DATABASES setting '%s' option set to sqlite3's ':memory:' value " "shouldn't interfere with transaction support detection." % option_key ) # Transaction support is properly initialized for the 'other' DB. self.assertTrue(other.features.supports_transactions, msg) # And all the DBs report that they support transactions. self.assertTrue(connections_support_transactions(), msg) class DummyBackendTest(unittest.TestCase): def test_setup_databases(self): """ setup_databases() doesn't fail with dummy database backend. """ tested_connections = db.ConnectionHandler({}) with mock.patch("django.test.utils.connections", new=tested_connections): runner_instance = DiscoverRunner(verbosity=0) old_config = runner_instance.setup_databases() runner_instance.teardown_databases(old_config) class AliasedDefaultTestSetupTest(unittest.TestCase): def test_setup_aliased_default_database(self): """ setup_databases() doesn't fail when 'default' is aliased """ tested_connections = db.ConnectionHandler( {"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}} ) with mock.patch("django.test.utils.connections", new=tested_connections): runner_instance = DiscoverRunner(verbosity=0) old_config = runner_instance.setup_databases() runner_instance.teardown_databases(old_config) class SetupDatabasesTests(SimpleTestCase): def setUp(self): self.runner_instance = DiscoverRunner(verbosity=0) def test_setup_aliased_databases(self): tested_connections = db.ConnectionHandler( { "default": { "ENGINE": "django.db.backends.dummy", "NAME": "dbname", }, "other": { "ENGINE": "django.db.backends.dummy", "NAME": "dbname", }, } ) with mock.patch( "django.db.backends.dummy.base.DatabaseWrapper.creation_class" ) as mocked_db_creation: with mock.patch("django.test.utils.connections", new=tested_connections): old_config = self.runner_instance.setup_databases() self.runner_instance.teardown_databases(old_config) mocked_db_creation.return_value.destroy_test_db.assert_called_once_with( "dbname", 0, False ) def test_setup_test_database_aliases(self): """ The default database must be the first because data migrations use the default alias by default. """ tested_connections = db.ConnectionHandler( { "other": { "ENGINE": "django.db.backends.dummy", "NAME": "dbname", }, "default": { "ENGINE": "django.db.backends.dummy", "NAME": "dbname", }, } ) with mock.patch("django.test.utils.connections", new=tested_connections): test_databases, _ = get_unique_databases_and_mirrors() self.assertEqual( test_databases, { ("", "", "django.db.backends.dummy", "test_dbname"): ( "dbname", ["default", "other"], ), }, ) def test_destroy_test_db_restores_db_name(self): tested_connections = db.ConnectionHandler( { "default": { "ENGINE": settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"], "NAME": "xxx_test_database", }, } ) # Using the real current name as old_name to not mess with the test suite. old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"] with mock.patch("django.db.connections", new=tested_connections): tested_connections["default"].creation.destroy_test_db( old_name, verbosity=0, keepdb=True ) self.assertEqual( tested_connections["default"].settings_dict["NAME"], old_name ) def test_serialization(self): tested_connections = db.ConnectionHandler( { "default": { "ENGINE": "django.db.backends.dummy", }, } ) with mock.patch( "django.db.backends.dummy.base.DatabaseWrapper.creation_class" ) as mocked_db_creation: with mock.patch("django.test.utils.connections", new=tested_connections): self.runner_instance.setup_databases() mocked_db_creation.return_value.create_test_db.assert_called_once_with( verbosity=0, autoclobber=False, serialize=True, keepdb=False ) def test_serialized_off(self): tested_connections = db.ConnectionHandler( { "default": { "ENGINE": "django.db.backends.dummy", "TEST": {"SERIALIZE": False}, }, } ) msg = ( "The SERIALIZE test database setting is deprecated as it can be " "inferred from the TestCase/TransactionTestCase.databases that " "enable the serialized_rollback feature." ) with mock.patch( "django.db.backends.dummy.base.DatabaseWrapper.creation_class" ) as mocked_db_creation: with mock.patch("django.test.utils.connections", new=tested_connections): with self.assertWarnsMessage(RemovedInDjango50Warning, msg): self.runner_instance.setup_databases() mocked_db_creation.return_value.create_test_db.assert_called_once_with( verbosity=0, autoclobber=False, serialize=False, keepdb=False ) @skipUnlessDBFeature("supports_sequence_reset") class AutoIncrementResetTest(TransactionTestCase): """ Creating the same models in different test methods receive the same PK values since the sequences are reset before each test method. """ available_apps = ["test_runner"] reset_sequences = True def _test(self): # Regular model p = Person.objects.create(first_name="Jack", last_name="Smith") self.assertEqual(p.pk, 1) # Auto-created many-to-many through model p.friends.add(Person.objects.create(first_name="Jacky", last_name="Smith")) self.assertEqual(p.friends.through.objects.first().pk, 1) # Many-to-many through model b = B.objects.create() t = Through.objects.create(person=p, b=b) self.assertEqual(t.pk, 1) def test_autoincrement_reset1(self): self._test() def test_autoincrement_reset2(self): self._test() class EmptyDefaultDatabaseTest(unittest.TestCase): def test_empty_default_database(self): """ An empty default database in settings does not raise an ImproperlyConfigured error when running a unit test that does not use a database. """ tested_connections = db.ConnectionHandler({"default": {}}) with mock.patch("django.db.connections", new=tested_connections): connection = tested_connections[db.utils.DEFAULT_DB_ALIAS] self.assertEqual( connection.settings_dict["ENGINE"], "django.db.backends.dummy" ) connections_support_transactions() class RunTestsExceptionHandlingTests(unittest.TestCase): def test_run_checks_raises(self): """ Teardown functions are run when run_checks() raises SystemCheckError. """ with mock.patch( "django.test.runner.DiscoverRunner.setup_test_environment" ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( "django.test.runner.DiscoverRunner.build_suite" ), mock.patch( "django.test.runner.DiscoverRunner.run_checks", side_effect=SystemCheckError ), mock.patch( "django.test.runner.DiscoverRunner.teardown_databases" ) as teardown_databases, mock.patch( "django.test.runner.DiscoverRunner.teardown_test_environment" ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(SystemCheckError): runner.run_tests( ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] ) self.assertTrue(teardown_databases.called) self.assertTrue(teardown_test_environment.called) def test_run_checks_raises_and_teardown_raises(self): """ SystemCheckError is surfaced when run_checks() raises SystemCheckError and teardown databases() raises ValueError. """ with mock.patch( "django.test.runner.DiscoverRunner.setup_test_environment" ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( "django.test.runner.DiscoverRunner.build_suite" ), mock.patch( "django.test.runner.DiscoverRunner.run_checks", side_effect=SystemCheckError ), mock.patch( "django.test.runner.DiscoverRunner.teardown_databases", side_effect=ValueError, ) as teardown_databases, mock.patch( "django.test.runner.DiscoverRunner.teardown_test_environment" ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(SystemCheckError): runner.run_tests( ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] ) self.assertTrue(teardown_databases.called) self.assertFalse(teardown_test_environment.called) def test_run_checks_passes_and_teardown_raises(self): """ Exceptions on teardown are surfaced if no exceptions happen during run_checks(). """ with mock.patch( "django.test.runner.DiscoverRunner.setup_test_environment" ), mock.patch("django.test.runner.DiscoverRunner.setup_databases"), mock.patch( "django.test.runner.DiscoverRunner.build_suite" ), mock.patch( "django.test.runner.DiscoverRunner.run_checks" ), mock.patch( "django.test.runner.DiscoverRunner.teardown_databases", side_effect=ValueError, ) as teardown_databases, mock.patch( "django.test.runner.DiscoverRunner.teardown_test_environment" ) as teardown_test_environment: runner = DiscoverRunner(verbosity=0, interactive=False) with self.assertRaises(ValueError): # Suppress the output when running TestDjangoTestCase. with mock.patch("sys.stderr"): runner.run_tests( ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"] ) self.assertTrue(teardown_databases.called) self.assertFalse(teardown_test_environment.called) # RemovedInDjango50Warning class NoOpTestRunner(DiscoverRunner): def setup_test_environment(self, **kwargs): return def setup_databases(self, **kwargs): return def run_checks(self, databases): return def teardown_databases(self, old_config, **kwargs): return def teardown_test_environment(self, **kwargs): return class DiscoverRunnerExtraTestsDeprecationTests(SimpleTestCase): msg = "The extra_tests argument is deprecated." def get_runner(self): return NoOpTestRunner(verbosity=0, interactive=False) def test_extra_tests_build_suite(self): runner = self.get_runner() with self.assertWarnsMessage(RemovedInDjango50Warning, self.msg): runner.build_suite(extra_tests=[]) def test_extra_tests_run_tests(self): runner = self.get_runner() with captured_stderr(): with self.assertWarnsMessage(RemovedInDjango50Warning, self.msg): runner.run_tests( test_labels=["test_runner_apps.sample.tests_sample.EmptyTestCase"], extra_tests=[], )
096aa3bef52a1697fbd3f0a20b1ef35253316a9c25ae1cda202c9d08a512751a
from django.db import models class Person(models.Model): first_name = models.CharField(max_length=20) last_name = models.CharField(max_length=20) friends = models.ManyToManyField("self") # A set of models that use a non-abstract inherited 'through' model. class ThroughBase(models.Model): person = models.ForeignKey(Person, models.CASCADE) b = models.ForeignKey("B", models.CASCADE) class Through(ThroughBase): extra = models.CharField(max_length=20) class B(models.Model): people = models.ManyToManyField(Person, through=Through)
9635d97a66123f26a1cdc56a4866247a02b9eacf2238443017fbda331ed4dcc7
from django.test.runner import DiscoverRunner class CustomOptionsTestRunner(DiscoverRunner): def __init__( self, verbosity=1, interactive=True, failfast=True, option_a=None, option_b=None, option_c=None, **kwargs, ): super().__init__( verbosity=verbosity, interactive=interactive, failfast=failfast ) self.option_a = option_a self.option_b = option_b self.option_c = option_c @classmethod def add_arguments(cls, parser): parser.add_argument("--option_a", "-a", default="1"), parser.add_argument("--option_b", "-b", default="2"), parser.add_argument("--option_c", "-c", default="3"), def run_tests(self, test_labels, **kwargs): print("%s:%s:%s" % (self.option_a, self.option_b, self.option_c))
8c3b2ece4439349c5beac32d7eca085c43c82aceec2728943dbaaecc5d0d635e
import unittest from io import StringIO from django.db import connection from django.test import TestCase from django.test.runner import DiscoverRunner from .models import Person @unittest.skipUnless( connection.vendor == "sqlite", "Only run on sqlite so we can check output SQL." ) class TestDebugSQL(unittest.TestCase): class PassingTest(TestCase): def runTest(self): Person.objects.filter(first_name="pass").count() class FailingTest(TestCase): def runTest(self): Person.objects.filter(first_name="fail").count() self.fail() class ErrorTest(TestCase): def runTest(self): Person.objects.filter(first_name="error").count() raise Exception class ErrorSetUpTestDataTest(TestCase): @classmethod def setUpTestData(cls): raise Exception def runTest(self): pass class PassingSubTest(TestCase): def runTest(self): with self.subTest(): Person.objects.filter(first_name="subtest-pass").count() class FailingSubTest(TestCase): def runTest(self): with self.subTest(): Person.objects.filter(first_name="subtest-fail").count() self.fail() class ErrorSubTest(TestCase): def runTest(self): with self.subTest(): Person.objects.filter(first_name="subtest-error").count() raise Exception def _test_output(self, verbosity): runner = DiscoverRunner(debug_sql=True, verbosity=0) suite = runner.test_suite() suite.addTest(self.FailingTest()) suite.addTest(self.ErrorTest()) suite.addTest(self.PassingTest()) suite.addTest(self.PassingSubTest()) suite.addTest(self.FailingSubTest()) suite.addTest(self.ErrorSubTest()) old_config = runner.setup_databases() stream = StringIO() resultclass = runner.get_resultclass() runner.test_runner( verbosity=verbosity, stream=stream, resultclass=resultclass, ).run(suite) runner.teardown_databases(old_config) return stream.getvalue() def test_output_normal(self): full_output = self._test_output(1) for output in self.expected_outputs: self.assertIn(output, full_output) for output in self.verbose_expected_outputs: self.assertNotIn(output, full_output) def test_output_verbose(self): full_output = self._test_output(2) for output in self.expected_outputs: self.assertIn(output, full_output) for output in self.verbose_expected_outputs: self.assertIn(output, full_output) expected_outputs = [ ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'error';""" ), ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'fail';""" ), ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'subtest-error';""" ), ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'subtest-fail';""" ), ] verbose_expected_outputs = [ "runTest (test_runner.test_debug_sql.TestDebugSQL.FailingTest) ... FAIL", "runTest (test_runner.test_debug_sql.TestDebugSQL.ErrorTest) ... ERROR", "runTest (test_runner.test_debug_sql.TestDebugSQL.PassingTest) ... ok", # If there are errors/failures in subtests but not in test itself, # the status is not written. That behavior comes from Python. "runTest (test_runner.test_debug_sql.TestDebugSQL.FailingSubTest) ...", "runTest (test_runner.test_debug_sql.TestDebugSQL.ErrorSubTest) ...", ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'pass';""" ), ( """SELECT COUNT(*) AS "__count" """ """FROM "test_runner_person" WHERE """ """"test_runner_person"."first_name" = 'subtest-pass';""" ), ] def test_setupclass_exception(self): runner = DiscoverRunner(debug_sql=True, verbosity=0) suite = runner.test_suite() suite.addTest(self.ErrorSetUpTestDataTest()) old_config = runner.setup_databases() stream = StringIO() runner.test_runner( verbosity=0, stream=stream, resultclass=runner.get_resultclass(), ).run(suite) runner.teardown_databases(old_config) output = stream.getvalue() self.assertIn( "ERROR: setUpClass " "(test_runner.test_debug_sql.TestDebugSQL.ErrorSetUpTestDataTest)", output, )
da77e04e54926b33974a74d880224196e44c64c395aa2cdd2c87206bf20ea224
from unittest import mock from django.test import SimpleTestCase from django.test.runner import Shuffler class ShufflerTests(SimpleTestCase): def test_hash_text(self): actual = Shuffler._hash_text("abcd") self.assertEqual(actual, "e2fc714c4727ee9395f324cd2e7f331f") def test_hash_text_hash_algorithm(self): class MyShuffler(Shuffler): hash_algorithm = "sha1" actual = MyShuffler._hash_text("abcd") self.assertEqual(actual, "81fe8bfe87576c3ecb22426f8e57847382917acf") def test_init(self): shuffler = Shuffler(100) self.assertEqual(shuffler.seed, 100) self.assertEqual(shuffler.seed_source, "given") def test_init_none_seed(self): with mock.patch("random.randint", return_value=200): shuffler = Shuffler(None) self.assertEqual(shuffler.seed, 200) self.assertEqual(shuffler.seed_source, "generated") def test_init_no_seed_argument(self): with mock.patch("random.randint", return_value=300): shuffler = Shuffler() self.assertEqual(shuffler.seed, 300) self.assertEqual(shuffler.seed_source, "generated") def test_seed_display(self): shuffler = Shuffler(100) shuffler.seed_source = "test" self.assertEqual(shuffler.seed_display, "100 (test)") def test_hash_item_seed(self): cases = [ (1234, "64ad3fb166ddb41a2ca24f1803b8b722"), # Passing a string gives the same value. ("1234", "64ad3fb166ddb41a2ca24f1803b8b722"), (5678, "4dde450ad339b6ce45a0a2666e35b975"), ] for seed, expected in cases: with self.subTest(seed=seed): shuffler = Shuffler(seed=seed) actual = shuffler._hash_item("abc", lambda x: x) self.assertEqual(actual, expected) def test_hash_item_key(self): cases = [ (lambda x: x, "64ad3fb166ddb41a2ca24f1803b8b722"), (lambda x: x.upper(), "ee22e8597bff91742affe4befbf4649a"), ] for key, expected in cases: with self.subTest(key=key): shuffler = Shuffler(seed=1234) actual = shuffler._hash_item("abc", key) self.assertEqual(actual, expected) def test_shuffle_key(self): cases = [ (lambda x: x, ["a", "d", "b", "c"]), (lambda x: x.upper(), ["d", "c", "a", "b"]), ] for num, (key, expected) in enumerate(cases, start=1): with self.subTest(num=num): shuffler = Shuffler(seed=1234) actual = shuffler.shuffle(["a", "b", "c", "d"], key) self.assertEqual(actual, expected) def test_shuffle_consistency(self): seq = [str(n) for n in range(5)] cases = [ (None, ["3", "0", "2", "4", "1"]), (0, ["3", "2", "4", "1"]), (1, ["3", "0", "2", "4"]), (2, ["3", "0", "4", "1"]), (3, ["0", "2", "4", "1"]), (4, ["3", "0", "2", "1"]), ] shuffler = Shuffler(seed=1234) for index, expected in cases: with self.subTest(index=index): if index is None: new_seq = seq else: new_seq = seq.copy() del new_seq[index] actual = shuffler.shuffle(new_seq, lambda x: x) self.assertEqual(actual, expected) def test_shuffle_same_hash(self): shuffler = Shuffler(seed=1234) msg = "item 'A' has same hash 'a56ce89262959e151ee2266552f1819c' as item 'a'" with self.assertRaisesMessage(RuntimeError, msg): shuffler.shuffle(["a", "b", "A"], lambda x: x.upper())
ebc2be6979d7919fe8838cdfef805b57716efa6bac7ef4fd9d2b4d5b2fac0849
import logging import multiprocessing import os import unittest.loader from argparse import ArgumentParser from contextlib import contextmanager from importlib import import_module from unittest import TestSuite, TextTestRunner, defaultTestLoader, mock from django.db import connections from django.test import SimpleTestCase from django.test.runner import DiscoverRunner, get_max_test_processes from django.test.utils import ( NullTimeKeeper, TimeKeeper, captured_stderr, captured_stdout, ) @contextmanager def change_cwd(directory): current_dir = os.path.abspath(os.path.dirname(__file__)) new_dir = os.path.join(current_dir, directory) old_cwd = os.getcwd() os.chdir(new_dir) try: yield finally: os.chdir(old_cwd) @contextmanager def change_loader_patterns(patterns): original_patterns = DiscoverRunner.test_loader.testNamePatterns DiscoverRunner.test_loader.testNamePatterns = patterns try: yield finally: DiscoverRunner.test_loader.testNamePatterns = original_patterns # Isolate from the real environment. @mock.patch.dict(os.environ, {}, clear=True) @mock.patch.object(multiprocessing, "cpu_count", return_value=12) # Python 3.8 on macOS defaults to 'spawn' mode. @mock.patch.object(multiprocessing, "get_start_method", return_value="fork") class DiscoverRunnerParallelArgumentTests(SimpleTestCase): def get_parser(self): parser = ArgumentParser() DiscoverRunner.add_arguments(parser) return parser def test_parallel_default(self, *mocked_objects): result = self.get_parser().parse_args([]) self.assertEqual(result.parallel, 0) def test_parallel_flag(self, *mocked_objects): result = self.get_parser().parse_args(["--parallel"]) self.assertEqual(result.parallel, "auto") def test_parallel_auto(self, *mocked_objects): result = self.get_parser().parse_args(["--parallel", "auto"]) self.assertEqual(result.parallel, "auto") def test_parallel_count(self, *mocked_objects): result = self.get_parser().parse_args(["--parallel", "17"]) self.assertEqual(result.parallel, 17) def test_parallel_invalid(self, *mocked_objects): with self.assertRaises(SystemExit), captured_stderr() as stderr: self.get_parser().parse_args(["--parallel", "unaccepted"]) msg = "argument --parallel: 'unaccepted' is not an integer or the string 'auto'" self.assertIn(msg, stderr.getvalue()) def test_get_max_test_processes(self, *mocked_objects): self.assertEqual(get_max_test_processes(), 12) @mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}) def test_get_max_test_processes_env_var(self, *mocked_objects): self.assertEqual(get_max_test_processes(), 7) def test_get_max_test_processes_spawn( self, mocked_get_start_method, mocked_cpu_count, ): mocked_get_start_method.return_value = "spawn" self.assertEqual(get_max_test_processes(), 1) with mock.patch.dict(os.environ, {"DJANGO_TEST_PROCESSES": "7"}): self.assertEqual(get_max_test_processes(), 1) class DiscoverRunnerTests(SimpleTestCase): @staticmethod def get_test_methods_names(suite): return [t.__class__.__name__ + "." + t._testMethodName for t in suite._tests] def test_init_debug_mode(self): runner = DiscoverRunner() self.assertFalse(runner.debug_mode) def test_add_arguments_shuffle(self): parser = ArgumentParser() DiscoverRunner.add_arguments(parser) ns = parser.parse_args([]) self.assertIs(ns.shuffle, False) ns = parser.parse_args(["--shuffle"]) self.assertIsNone(ns.shuffle) ns = parser.parse_args(["--shuffle", "5"]) self.assertEqual(ns.shuffle, 5) def test_add_arguments_debug_mode(self): parser = ArgumentParser() DiscoverRunner.add_arguments(parser) ns = parser.parse_args([]) self.assertFalse(ns.debug_mode) ns = parser.parse_args(["--debug-mode"]) self.assertTrue(ns.debug_mode) def test_setup_shuffler_no_shuffle_argument(self): runner = DiscoverRunner() self.assertIs(runner.shuffle, False) runner.setup_shuffler() self.assertIsNone(runner.shuffle_seed) def test_setup_shuffler_shuffle_none(self): runner = DiscoverRunner(shuffle=None) self.assertIsNone(runner.shuffle) with mock.patch("random.randint", return_value=1): with captured_stdout() as stdout: runner.setup_shuffler() self.assertEqual(stdout.getvalue(), "Using shuffle seed: 1 (generated)\n") self.assertEqual(runner.shuffle_seed, 1) def test_setup_shuffler_shuffle_int(self): runner = DiscoverRunner(shuffle=2) self.assertEqual(runner.shuffle, 2) with captured_stdout() as stdout: runner.setup_shuffler() expected_out = "Using shuffle seed: 2 (given)\n" self.assertEqual(stdout.getvalue(), expected_out) self.assertEqual(runner.shuffle_seed, 2) def test_load_tests_for_label_file_path(self): with change_cwd("."): msg = ( "One of the test labels is a path to a file: " "'test_discover_runner.py', which is not supported. Use a " "dotted module name or path to a directory instead." ) with self.assertRaisesMessage(RuntimeError, msg): DiscoverRunner().load_tests_for_label("test_discover_runner.py", {}) def test_dotted_test_module(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests_sample"], ) .countTestCases() ) self.assertEqual(count, 4) def test_dotted_test_class_vanilla_unittest(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests_sample.TestVanillaUnittest"], ) .countTestCases() ) self.assertEqual(count, 1) def test_dotted_test_class_django_testcase(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests_sample.TestDjangoTestCase"], ) .countTestCases() ) self.assertEqual(count, 1) def test_dotted_test_method_django_testcase(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests_sample.TestDjangoTestCase.test_sample"], ) .countTestCases() ) self.assertEqual(count, 1) def test_pattern(self): count = ( DiscoverRunner( pattern="*_tests.py", verbosity=0, ) .build_suite(["test_runner_apps.sample"]) .countTestCases() ) self.assertEqual(count, 1) def test_name_patterns(self): all_test_1 = [ "DjangoCase1.test_1", "DjangoCase2.test_1", "SimpleCase1.test_1", "SimpleCase2.test_1", "UnittestCase1.test_1", "UnittestCase2.test_1", ] all_test_2 = [ "DjangoCase1.test_2", "DjangoCase2.test_2", "SimpleCase1.test_2", "SimpleCase2.test_2", "UnittestCase1.test_2", "UnittestCase2.test_2", ] all_tests = sorted([*all_test_1, *all_test_2, "UnittestCase2.test_3_test"]) for pattern, expected in [ [["test_1"], all_test_1], [["UnittestCase1"], ["UnittestCase1.test_1", "UnittestCase1.test_2"]], [["*test"], ["UnittestCase2.test_3_test"]], [["test*"], all_tests], [["test"], all_tests], [["test_1", "test_2"], sorted([*all_test_1, *all_test_2])], [["test*1"], all_test_1], ]: with self.subTest(pattern): suite = DiscoverRunner( test_name_patterns=pattern, verbosity=0, ).build_suite(["test_runner_apps.simple"]) self.assertEqual(expected, self.get_test_methods_names(suite)) def test_loader_patterns_not_mutated(self): runner = DiscoverRunner(test_name_patterns=["test_sample"], verbosity=0) tests = [ ("test_runner_apps.sample.tests", 1), ("test_runner_apps.sample.tests.Test.test_sample", 1), ("test_runner_apps.sample.empty", 0), ("test_runner_apps.sample.tests_sample.EmptyTestCase", 0), ] for test_labels, tests_count in tests: with self.subTest(test_labels=test_labels): with change_loader_patterns(["UnittestCase1"]): count = runner.build_suite([test_labels]).countTestCases() self.assertEqual(count, tests_count) self.assertEqual( runner.test_loader.testNamePatterns, ["UnittestCase1"] ) def test_loader_patterns_not_mutated_when_test_label_is_file_path(self): runner = DiscoverRunner(test_name_patterns=["test_sample"], verbosity=0) with change_cwd("."), change_loader_patterns(["UnittestCase1"]): with self.assertRaises(RuntimeError): runner.build_suite(["test_discover_runner.py"]) self.assertEqual(runner.test_loader.testNamePatterns, ["UnittestCase1"]) def test_file_path(self): with change_cwd(".."): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps/sample/"], ) .countTestCases() ) self.assertEqual(count, 5) def test_empty_label(self): """ If the test label is empty, discovery should happen on the current working directory. """ with change_cwd("."): suite = DiscoverRunner(verbosity=0).build_suite([]) self.assertEqual( suite._tests[0].id().split(".")[0], os.path.basename(os.getcwd()), ) def test_empty_test_case(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests_sample.EmptyTestCase"], ) .countTestCases() ) self.assertEqual(count, 0) def test_discovery_on_package(self): count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.tests"], ) .countTestCases() ) self.assertEqual(count, 1) def test_ignore_adjacent(self): """ When given a dotted path to a module, unittest discovery searches not just the module, but also the directory containing the module. This results in tests from adjacent modules being run when they should not. The discover runner avoids this behavior. """ count = ( DiscoverRunner(verbosity=0) .build_suite( ["test_runner_apps.sample.empty"], ) .countTestCases() ) self.assertEqual(count, 0) def test_testcase_ordering(self): with change_cwd(".."): suite = DiscoverRunner(verbosity=0).build_suite( ["test_runner_apps/sample/"] ) self.assertEqual( suite._tests[0].__class__.__name__, "TestDjangoTestCase", msg="TestDjangoTestCase should be the first test case", ) self.assertEqual( suite._tests[1].__class__.__name__, "TestZimpleTestCase", msg="TestZimpleTestCase should be the second test case", ) # All others can follow in unspecified order, including doctests self.assertIn( "DocTestCase", [t.__class__.__name__ for t in suite._tests[2:]] ) def test_duplicates_ignored(self): """ Tests shouldn't be discovered twice when discovering on overlapping paths. """ base_app = "forms_tests" sub_app = "forms_tests.field_tests" runner = DiscoverRunner(verbosity=0) with self.modify_settings(INSTALLED_APPS={"append": sub_app}): single = runner.build_suite([base_app]).countTestCases() dups = runner.build_suite([base_app, sub_app]).countTestCases() self.assertEqual(single, dups) def test_reverse(self): """ Reverse should reorder tests while maintaining the grouping specified by ``DiscoverRunner.reorder_by``. """ runner = DiscoverRunner(reverse=True, verbosity=0) suite = runner.build_suite( test_labels=("test_runner_apps.sample", "test_runner_apps.simple") ) self.assertIn( "test_runner_apps.simple", next(iter(suite)).id(), msg="Test labels should be reversed.", ) suite = runner.build_suite(test_labels=("test_runner_apps.simple",)) suite = tuple(suite) self.assertIn( "DjangoCase", suite[0].id(), msg="Test groups should not be reversed." ) self.assertIn( "SimpleCase", suite[4].id(), msg="Test groups order should be preserved." ) self.assertIn( "DjangoCase2", suite[0].id(), msg="Django test cases should be reversed." ) self.assertIn( "SimpleCase2", suite[4].id(), msg="Simple test cases should be reversed." ) self.assertIn( "UnittestCase2", suite[8].id(), msg="Unittest test cases should be reversed.", ) self.assertIn( "test_2", suite[0].id(), msg="Methods of Django cases should be reversed." ) self.assertIn( "test_2", suite[4].id(), msg="Methods of simple cases should be reversed." ) self.assertIn( "test_2", suite[9].id(), msg="Methods of unittest cases should be reversed." ) def test_build_suite_failed_tests_first(self): # The "doesnotexist" label results in a _FailedTest instance. suite = DiscoverRunner(verbosity=0).build_suite( test_labels=["test_runner_apps.sample", "doesnotexist"], ) tests = list(suite) self.assertIsInstance(tests[0], unittest.loader._FailedTest) self.assertNotIsInstance(tests[-1], unittest.loader._FailedTest) def test_build_suite_shuffling(self): # These will result in unittest.loader._FailedTest instances rather # than TestCase objects, but they are sufficient for testing. labels = ["label1", "label2", "label3", "label4"] cases = [ ({}, ["label1", "label2", "label3", "label4"]), ({"reverse": True}, ["label4", "label3", "label2", "label1"]), ({"shuffle": 8}, ["label4", "label1", "label3", "label2"]), ({"shuffle": 8, "reverse": True}, ["label2", "label3", "label1", "label4"]), ] for kwargs, expected in cases: with self.subTest(kwargs=kwargs): # Prevent writing the seed to stdout. runner = DiscoverRunner(**kwargs, verbosity=0) tests = runner.build_suite(test_labels=labels) # The ids have the form "unittest.loader._FailedTest.label1". names = [test.id().split(".")[-1] for test in tests] self.assertEqual(names, expected) def test_overridable_get_test_runner_kwargs(self): self.assertIsInstance(DiscoverRunner().get_test_runner_kwargs(), dict) def test_overridable_test_suite(self): self.assertEqual(DiscoverRunner().test_suite, TestSuite) def test_overridable_test_runner(self): self.assertEqual(DiscoverRunner().test_runner, TextTestRunner) def test_overridable_test_loader(self): self.assertEqual(DiscoverRunner().test_loader, defaultTestLoader) def test_tags(self): runner = DiscoverRunner(tags=["core"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 1 ) runner = DiscoverRunner(tags=["fast"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 2 ) runner = DiscoverRunner(tags=["slow"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 2 ) def test_exclude_tags(self): runner = DiscoverRunner(tags=["fast"], exclude_tags=["core"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 1 ) runner = DiscoverRunner(tags=["fast"], exclude_tags=["slow"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 0 ) runner = DiscoverRunner(exclude_tags=["slow"], verbosity=0) self.assertEqual( runner.build_suite(["test_runner_apps.tagged.tests"]).countTestCases(), 0 ) def test_tag_inheritance(self): def count_tests(**kwargs): kwargs.setdefault("verbosity", 0) suite = DiscoverRunner(**kwargs).build_suite( ["test_runner_apps.tagged.tests_inheritance"] ) return suite.countTestCases() self.assertEqual(count_tests(tags=["foo"]), 4) self.assertEqual(count_tests(tags=["bar"]), 2) self.assertEqual(count_tests(tags=["baz"]), 2) self.assertEqual(count_tests(tags=["foo"], exclude_tags=["bar"]), 2) self.assertEqual(count_tests(tags=["foo"], exclude_tags=["bar", "baz"]), 1) self.assertEqual(count_tests(exclude_tags=["foo"]), 0) def test_tag_fail_to_load(self): with self.assertRaises(SyntaxError): import_module("test_runner_apps.tagged.tests_syntax_error") runner = DiscoverRunner(tags=["syntax_error"], verbosity=0) # A label that doesn't exist or cannot be loaded due to syntax errors # is always considered matching. suite = runner.build_suite(["doesnotexist", "test_runner_apps.tagged"]) self.assertEqual( [test.id() for test in suite], [ "unittest.loader._FailedTest.doesnotexist", "unittest.loader._FailedTest.test_runner_apps.tagged." "tests_syntax_error", ], ) def test_included_tags_displayed(self): runner = DiscoverRunner(tags=["foo", "bar"], verbosity=2) with captured_stdout() as stdout: runner.build_suite(["test_runner_apps.tagged.tests"]) self.assertIn("Including test tag(s): bar, foo.\n", stdout.getvalue()) def test_excluded_tags_displayed(self): runner = DiscoverRunner(exclude_tags=["foo", "bar"], verbosity=3) with captured_stdout() as stdout: runner.build_suite(["test_runner_apps.tagged.tests"]) self.assertIn("Excluding test tag(s): bar, foo.\n", stdout.getvalue()) def test_number_of_tests_found_displayed(self): runner = DiscoverRunner() with captured_stdout() as stdout: runner.build_suite( [ "test_runner_apps.sample.tests_sample.TestDjangoTestCase", "test_runner_apps.simple", ] ) self.assertIn("Found 14 test(s).\n", stdout.getvalue()) def test_pdb_with_parallel(self): msg = "You cannot use --pdb with parallel tests; pass --parallel=1 to use it." with self.assertRaisesMessage(ValueError, msg): DiscoverRunner(pdb=True, parallel=2) def test_number_of_parallel_workers(self): """Number of processes doesn't exceed the number of TestCases.""" runner = DiscoverRunner(parallel=5, verbosity=0) suite = runner.build_suite(["test_runner_apps.tagged"]) self.assertEqual(suite.processes, len(suite.subsuites)) def test_number_of_databases_parallel_test_suite(self): """ Number of databases doesn't exceed the number of TestCases with parallel tests. """ runner = DiscoverRunner(parallel=8, verbosity=0) suite = runner.build_suite(["test_runner_apps.tagged"]) self.assertEqual(suite.processes, len(suite.subsuites)) self.assertEqual(runner.parallel, suite.processes) def test_number_of_databases_no_parallel_test_suite(self): """ Number of databases doesn't exceed the number of TestCases with non-parallel tests. """ runner = DiscoverRunner(parallel=8, verbosity=0) suite = runner.build_suite(["test_runner_apps.simple.tests.DjangoCase1"]) self.assertEqual(runner.parallel, 1) self.assertIsInstance(suite, TestSuite) def test_buffer_mode_test_pass(self): runner = DiscoverRunner(buffer=True, verbosity=0) with captured_stdout() as stdout, captured_stderr() as stderr: suite = runner.build_suite( [ "test_runner_apps.buffer.tests_buffer.WriteToStdoutStderrTestCase." "test_pass", ] ) runner.run_suite(suite) self.assertNotIn("Write to stderr.", stderr.getvalue()) self.assertNotIn("Write to stdout.", stdout.getvalue()) def test_buffer_mode_test_fail(self): runner = DiscoverRunner(buffer=True, verbosity=0) with captured_stdout() as stdout, captured_stderr() as stderr: suite = runner.build_suite( [ "test_runner_apps.buffer.tests_buffer.WriteToStdoutStderrTestCase." "test_fail", ] ) runner.run_suite(suite) self.assertIn("Write to stderr.", stderr.getvalue()) self.assertIn("Write to stdout.", stdout.getvalue()) def run_suite_with_runner(self, runner_class, **kwargs): class MyRunner(DiscoverRunner): def test_runner(self, *args, **kwargs): return runner_class() runner = MyRunner(**kwargs) # Suppress logging "Using shuffle seed" to the console. with captured_stdout(): runner.setup_shuffler() with captured_stdout() as stdout: try: result = runner.run_suite(None) except RuntimeError as exc: result = str(exc) output = stdout.getvalue() return result, output def test_run_suite_logs_seed(self): class TestRunner: def run(self, suite): return "<fake-result>" expected_prefix = "Used shuffle seed" # Test with and without shuffling enabled. result, output = self.run_suite_with_runner(TestRunner) self.assertEqual(result, "<fake-result>") self.assertNotIn(expected_prefix, output) result, output = self.run_suite_with_runner(TestRunner, shuffle=2) self.assertEqual(result, "<fake-result>") expected_output = f"{expected_prefix}: 2 (given)\n" self.assertEqual(output, expected_output) def test_run_suite_logs_seed_exception(self): """ run_suite() logs the seed when TestRunner.run() raises an exception. """ class TestRunner: def run(self, suite): raise RuntimeError("my exception") result, output = self.run_suite_with_runner(TestRunner, shuffle=2) self.assertEqual(result, "my exception") expected_output = "Used shuffle seed: 2 (given)\n" self.assertEqual(output, expected_output) @mock.patch("faulthandler.enable") def test_faulthandler_enabled(self, mocked_enable): with mock.patch("faulthandler.is_enabled", return_value=False): DiscoverRunner(enable_faulthandler=True) mocked_enable.assert_called() @mock.patch("faulthandler.enable") def test_faulthandler_already_enabled(self, mocked_enable): with mock.patch("faulthandler.is_enabled", return_value=True): DiscoverRunner(enable_faulthandler=True) mocked_enable.assert_not_called() @mock.patch("faulthandler.enable") def test_faulthandler_enabled_fileno(self, mocked_enable): # sys.stderr that is not an actual file. with mock.patch( "faulthandler.is_enabled", return_value=False ), captured_stderr(): DiscoverRunner(enable_faulthandler=True) mocked_enable.assert_called() @mock.patch("faulthandler.enable") def test_faulthandler_disabled(self, mocked_enable): with mock.patch("faulthandler.is_enabled", return_value=False): DiscoverRunner(enable_faulthandler=False) mocked_enable.assert_not_called() def test_timings_not_captured(self): runner = DiscoverRunner(timing=False) with captured_stderr() as stderr: with runner.time_keeper.timed("test"): pass runner.time_keeper.print_results() self.assertIsInstance(runner.time_keeper, NullTimeKeeper) self.assertNotIn("test", stderr.getvalue()) def test_timings_captured(self): runner = DiscoverRunner(timing=True) with captured_stderr() as stderr: with runner.time_keeper.timed("test"): pass runner.time_keeper.print_results() self.assertIsInstance(runner.time_keeper, TimeKeeper) self.assertIn("test", stderr.getvalue()) def test_log(self): custom_low_level = 5 custom_high_level = 45 msg = "logging message" cases = [ (0, None, False), (0, custom_low_level, False), (0, logging.DEBUG, False), (0, logging.INFO, False), (0, logging.WARNING, False), (0, custom_high_level, False), (1, None, True), (1, custom_low_level, False), (1, logging.DEBUG, False), (1, logging.INFO, True), (1, logging.WARNING, True), (1, custom_high_level, True), (2, None, True), (2, custom_low_level, True), (2, logging.DEBUG, True), (2, logging.INFO, True), (2, logging.WARNING, True), (2, custom_high_level, True), (3, None, True), (3, custom_low_level, True), (3, logging.DEBUG, True), (3, logging.INFO, True), (3, logging.WARNING, True), (3, custom_high_level, True), ] for verbosity, level, output in cases: with self.subTest(verbosity=verbosity, level=level): with captured_stdout() as stdout: runner = DiscoverRunner(verbosity=verbosity) runner.log(msg, level) self.assertEqual(stdout.getvalue(), f"{msg}\n" if output else "") def test_log_logger(self): logger = logging.getLogger("test.logging") cases = [ (None, "INFO:test.logging:log message"), # Test a low custom logging level. (5, "Level 5:test.logging:log message"), (logging.DEBUG, "DEBUG:test.logging:log message"), (logging.INFO, "INFO:test.logging:log message"), (logging.WARNING, "WARNING:test.logging:log message"), # Test a high custom logging level. (45, "Level 45:test.logging:log message"), ] for level, expected in cases: with self.subTest(level=level): runner = DiscoverRunner(logger=logger) # Pass a logging level smaller than the smallest level in cases # in order to capture all messages. with self.assertLogs("test.logging", level=1) as cm: runner.log("log message", level) self.assertEqual(cm.output, [expected]) def test_suite_result_with_failure(self): cases = [ (1, "FailureTestCase"), (1, "ErrorTestCase"), (0, "ExpectedFailureTestCase"), (1, "UnexpectedSuccessTestCase"), ] runner = DiscoverRunner(verbosity=0) for expected_failures, testcase in cases: with self.subTest(testcase=testcase): suite = runner.build_suite( [ f"test_runner_apps.failures.tests_failures.{testcase}", ] ) with captured_stderr(): result = runner.run_suite(suite) failures = runner.suite_result(suite, result) self.assertEqual(failures, expected_failures) class DiscoverRunnerGetDatabasesTests(SimpleTestCase): runner = DiscoverRunner(verbosity=2) skip_msg = "Skipping setup of unused database(s): " def get_databases(self, test_labels): with captured_stdout() as stdout: suite = self.runner.build_suite(test_labels) databases = self.runner.get_databases(suite) return databases, stdout.getvalue() def assertSkippedDatabases(self, test_labels, expected_databases): databases, output = self.get_databases(test_labels) self.assertEqual(databases, expected_databases) skipped_databases = set(connections) - set(expected_databases) if skipped_databases: self.assertIn(self.skip_msg + ", ".join(sorted(skipped_databases)), output) else: self.assertNotIn(self.skip_msg, output) def test_mixed(self): databases, output = self.get_databases(["test_runner_apps.databases.tests"]) self.assertEqual(databases, {"default": True, "other": False}) self.assertNotIn(self.skip_msg, output) def test_all(self): databases, output = self.get_databases( ["test_runner_apps.databases.tests.AllDatabasesTests"] ) self.assertEqual(databases, {alias: False for alias in connections}) self.assertNotIn(self.skip_msg, output) def test_default_and_other(self): self.assertSkippedDatabases( [ "test_runner_apps.databases.tests.DefaultDatabaseTests", "test_runner_apps.databases.tests.OtherDatabaseTests", ], {"default": False, "other": False}, ) def test_default_only(self): self.assertSkippedDatabases( [ "test_runner_apps.databases.tests.DefaultDatabaseTests", ], {"default": False}, ) def test_other_only(self): self.assertSkippedDatabases( ["test_runner_apps.databases.tests.OtherDatabaseTests"], {"other": False} ) def test_no_databases_required(self): self.assertSkippedDatabases( ["test_runner_apps.databases.tests.NoDatabaseTests"], {} ) def test_serialize(self): databases, _ = self.get_databases( ["test_runner_apps.databases.tests.DefaultDatabaseSerializedTests"] ) self.assertEqual(databases, {"default": True})
3bf076ded3368afdb8e6fe11696cab9eaf80f5a5cd81eaa9d945cc0b524ea30c
import pickle import sys import unittest from django.test import SimpleTestCase from django.test.runner import RemoteTestResult try: import tblib.pickling_support except ImportError: tblib = None class ExceptionThatFailsUnpickling(Exception): """ After pickling, this class fails unpickling with an error about incorrect arguments passed to __init__(). """ def __init__(self, arg): super().__init__() class ParallelTestRunnerTest(SimpleTestCase): """ End-to-end tests of the parallel test runner. These tests are only meaningful when running tests in parallel using the --parallel option, though it doesn't hurt to run them not in parallel. """ def test_subtest(self): """ Passing subtests work. """ for i in range(2): with self.subTest(index=i): self.assertEqual(i, i) class SampleFailingSubtest(SimpleTestCase): # This method name doesn't begin with "test" to prevent test discovery # from seeing it. def dummy_test(self): """ A dummy test for testing subTest failures. """ for i in range(3): with self.subTest(index=i): self.assertEqual(i, 1) class RemoteTestResultTest(SimpleTestCase): def _test_error_exc_info(self): try: raise ValueError("woops") except ValueError: return sys.exc_info() def test_was_successful_no_events(self): result = RemoteTestResult() self.assertIs(result.wasSuccessful(), True) def test_was_successful_one_success(self): result = RemoteTestResult() result.addSuccess(None) self.assertIs(result.wasSuccessful(), True) def test_was_successful_one_expected_failure(self): result = RemoteTestResult() result.addExpectedFailure(None, self._test_error_exc_info()) self.assertIs(result.wasSuccessful(), True) def test_was_successful_one_skip(self): result = RemoteTestResult() result.addSkip(None, "Skipped") self.assertIs(result.wasSuccessful(), True) @unittest.skipUnless(tblib is not None, "requires tblib to be installed") def test_was_successful_one_error(self): result = RemoteTestResult() result.addError(None, self._test_error_exc_info()) self.assertIs(result.wasSuccessful(), False) @unittest.skipUnless(tblib is not None, "requires tblib to be installed") def test_was_successful_one_failure(self): result = RemoteTestResult() result.addFailure(None, self._test_error_exc_info()) self.assertIs(result.wasSuccessful(), False) def test_picklable(self): result = RemoteTestResult() loaded_result = pickle.loads(pickle.dumps(result)) self.assertEqual(result.events, loaded_result.events) def test_pickle_errors_detection(self): picklable_error = RuntimeError("This is fine") not_unpicklable_error = ExceptionThatFailsUnpickling("arg") result = RemoteTestResult() result._confirm_picklable(picklable_error) msg = "__init__() missing 1 required positional argument" with self.assertRaisesMessage(TypeError, msg): result._confirm_picklable(not_unpicklable_error) @unittest.skipUnless(tblib is not None, "requires tblib to be installed") def test_add_failing_subtests(self): """ Failing subtests are added correctly using addSubTest(). """ # Manually run a test with failing subtests to prevent the failures # from affecting the actual test run. result = RemoteTestResult() subtest_test = SampleFailingSubtest(methodName="dummy_test") subtest_test.run(result=result) events = result.events self.assertEqual(len(events), 4) self.assertIs(result.wasSuccessful(), False) event = events[1] self.assertEqual(event[0], "addSubTest") self.assertEqual( str(event[2]), "dummy_test (test_runner.test_parallel.SampleFailingSubtest) (index=0)", ) self.assertEqual(repr(event[3][1]), "AssertionError('0 != 1')") event = events[2] self.assertEqual(repr(event[3][1]), "AssertionError('2 != 1')")
bc59a97d9f15862370c8a0603e413d9bafad0139f1e98c64cb146b93c7114402
from django.db.models import Q from django.test import TestCase from .models import Comment, Forum, Item, Post, PropertyValue, SystemDetails, SystemInfo class NullFkTests(TestCase): def test_null_fk(self): d = SystemDetails.objects.create(details="First details") s = SystemInfo.objects.create(system_name="First forum", system_details=d) f = Forum.objects.create(system_info=s, forum_name="First forum") p = Post.objects.create(forum=f, title="First Post") c1 = Comment.objects.create(post=p, comment_text="My first comment") c2 = Comment.objects.create(comment_text="My second comment") # Starting from comment, make sure that a .select_related(...) with a specified # set of fields will properly LEFT JOIN multiple levels of NULLs (and the things # that come after the NULLs, or else data that should exist won't). Regression # test for #7369. c = Comment.objects.select_related().get(id=c1.id) self.assertEqual(c.post, p) self.assertIsNone(Comment.objects.select_related().get(id=c2.id).post) self.assertQuerysetEqual( Comment.objects.select_related("post__forum__system_info").all(), [ (c1.id, "My first comment", "<Post: First Post>"), (c2.id, "My second comment", "None"), ], transform=lambda c: (c.id, c.comment_text, repr(c.post)), ) # Regression test for #7530, #7716. self.assertIsNone( Comment.objects.select_related("post").filter(post__isnull=True)[0].post ) self.assertQuerysetEqual( Comment.objects.select_related("post__forum__system_info__system_details"), [ (c1.id, "My first comment", "<Post: First Post>"), (c2.id, "My second comment", "None"), ], transform=lambda c: (c.id, c.comment_text, repr(c.post)), ) def test_combine_isnull(self): item = Item.objects.create(title="Some Item") pv = PropertyValue.objects.create(label="Some Value") item.props.create(key="a", value=pv) item.props.create(key="b") # value=NULL q1 = Q(props__key="a", props__value=pv) q2 = Q(props__key="b", props__value__isnull=True) # Each of these individually should return the item. self.assertEqual(Item.objects.get(q1), item) self.assertEqual(Item.objects.get(q2), item) # Logically, qs1 and qs2, and qs3 and qs4 should be the same. qs1 = Item.objects.filter(q1) & Item.objects.filter(q2) qs2 = Item.objects.filter(q2) & Item.objects.filter(q1) qs3 = Item.objects.filter(q1) | Item.objects.filter(q2) qs4 = Item.objects.filter(q2) | Item.objects.filter(q1) # Regression test for #15823. self.assertEqual(list(qs1), list(qs2)) self.assertEqual(list(qs3), list(qs4))
7239913311c812c5c388f6528caf83b96ac0879825e96c903d4a56a8ca42774b
""" Regression tests for proper working of ForeignKey(null=True). """ from django.db import models class SystemDetails(models.Model): details = models.TextField() class SystemInfo(models.Model): system_details = models.ForeignKey(SystemDetails, models.CASCADE) system_name = models.CharField(max_length=32) class Forum(models.Model): system_info = models.ForeignKey(SystemInfo, models.CASCADE) forum_name = models.CharField(max_length=32) class Post(models.Model): forum = models.ForeignKey(Forum, models.SET_NULL, null=True) title = models.CharField(max_length=32) def __str__(self): return self.title class Comment(models.Model): post = models.ForeignKey(Post, models.SET_NULL, null=True) comment_text = models.CharField(max_length=250) class Meta: ordering = ("comment_text",) # Ticket 15823 class Item(models.Model): title = models.CharField(max_length=100) class PropertyValue(models.Model): label = models.CharField(max_length=100) class Property(models.Model): item = models.ForeignKey(Item, models.CASCADE, related_name="props") key = models.CharField(max_length=100) value = models.ForeignKey(PropertyValue, models.SET_NULL, null=True)
01fe0a3258f001995b1bed4772c5892f88a548a2d6f626577b97a74f042a57d5
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, display_for_field, display_for_value, flatten, flatten_fieldsets, help_text_for_field, label_for_field, lookup_field, quote, ) from django.db import DEFAULT_DB_ALIAS, models from django.test import SimpleTestCase, TestCase, override_settings from django.utils.formats import localize from django.utils.safestring import mark_safe from .models import Article, Car, Count, Event, EventGuide, Location, Site, Vehicle class NestedObjectsTests(TestCase): """ Tests for ``NestedObject`` utility collection. """ @classmethod def setUpTestData(cls): cls.n = NestedObjects(using=DEFAULT_DB_ALIAS) cls.objs = [Count.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()]) 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), ) 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_null_display_for_field(self): """ Regression test for #12550: display_for_field should handle None value. """ display_value = display_for_field(None, models.CharField(), self.empty_value) self.assertEqual(display_value, self.empty_value) display_value = display_for_field( None, models.CharField(choices=((None, "test_none"),)), self.empty_value ) self.assertEqual(display_value, "test_none") display_value = display_for_field(None, models.DateField(), self.empty_value) self.assertEqual(display_value, self.empty_value) display_value = display_for_field(None, models.TimeField(), self.empty_value) self.assertEqual(display_value, self.empty_value) display_value = display_for_field( None, models.BooleanField(null=True), self.empty_value ) expected = ( '<img src="%sadmin/img/icon-unknown.svg" alt="None" />' % settings.STATIC_URL ) self.assertHTMLEqual(display_value, expected) display_value = display_for_field(None, models.DecimalField(), self.empty_value) self.assertEqual(display_value, self.empty_value) display_value = display_for_field(None, models.FloatField(), self.empty_value) self.assertEqual(display_value, self.empty_value) display_value = display_for_field(None, models.JSONField(), self.empty_value) self.assertEqual(display_value, self.empty_value) 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_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") 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_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") 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">&amp;text:</label>', ) self.assertHTMLEqual( helpers.AdminField(form, "cb", is_first=False).label_tag(), '<label for="id_cb" class="vCheckboxLabel required inline">&amp;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")
411c779f228898cc907ef7103ff7cf8c1d6c37ec2d642be28adea2e52f4f9e83
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 Count(models.Model): num = models.PositiveSmallIntegerField() parent = models.ForeignKey("self", models.CASCADE, null=True) def __str__(self): return str(self.num) 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
08b4326f6a6076619c5da8b84e0e3e913d134b65ed380e4255579ec8e4f61c0e
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)
005f9eef627c1b76657109925cb8fd6bec2f3f37c30d5c954fe8d085c7f5e199
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.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, 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="[email protected]" ) 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), ) content_type_pk = ContentType.objects.get_for_model(Article).pk LogEntry.objects.log_action( cls.user.pk, content_type_pk, cls.a1.pk, repr(cls.a1), CHANGE, change_message="Changed something", ) def setUp(self): self.client.force_login(self.user) 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.assertQuerysetEqual(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_action(self): content_type_pk = ContentType.objects.get_for_model(Article).pk log_entry = LogEntry.objects.log_action( self.user.pk, content_type_pk, self.a1.pk, repr(self.a1), CHANGE, change_message="Changed something else", ) self.assertEqual(log_entry, LogEntry.objects.latest("id")) 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(repr(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") # 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) # 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) # 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) 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)
5e46f7c5d83e2527fd2733d24c747b2d9d4ec87c6d45b79287f7c56c365bc6d5
from django.urls import path from .admin import site urlpatterns = [ path("test_admin/admin/", site.urls), ]
2612233f1f8964595e0216c3ab5134fd783190135dc8cd8aa9f268c59fc18c41
from unittest import mock from django.db import transaction from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature from .models import Article, InheritedArticleA, InheritedArticleB, Publication, User class ManyToManyTests(TestCase): @classmethod def setUpTestData(cls): # Create a couple of Publications. cls.p1 = Publication.objects.create(title="The Python Journal") cls.p2 = Publication.objects.create(title="Science News") cls.p3 = Publication.objects.create(title="Science Weekly") cls.p4 = Publication.objects.create(title="Highlights for Children") cls.a1 = Article.objects.create( headline="Django lets you build web apps easily" ) cls.a1.publications.add(cls.p1) cls.a2 = Article.objects.create(headline="NASA uses Python") cls.a2.publications.add(cls.p1, cls.p2, cls.p3, cls.p4) cls.a3 = Article.objects.create(headline="NASA finds intelligent life on Earth") cls.a3.publications.add(cls.p2) cls.a4 = Article.objects.create(headline="Oxygen-free diet works wonders") cls.a4.publications.add(cls.p2) def test_add(self): # Create an Article. a5 = Article(headline="Django lets you create web apps easily") # You can't associate it with a Publication until it's been saved. msg = ( '"<Article: Django lets you create web apps easily>" needs to have ' 'a value for field "id" before this many-to-many relationship can be used.' ) with self.assertRaisesMessage(ValueError, msg): getattr(a5, "publications") # Save it! a5.save() # Associate the Article with a Publication. a5.publications.add(self.p1) self.assertSequenceEqual(a5.publications.all(), [self.p1]) # Create another Article, and set it to appear in both Publications. a6 = Article(headline="ESA uses Python") a6.save() a6.publications.add(self.p1, self.p2) a6.publications.add(self.p3) # Adding a second time is OK a6.publications.add(self.p3) self.assertSequenceEqual( a6.publications.all(), [self.p2, self.p3, self.p1], ) # Adding an object of the wrong type raises TypeError msg = ( "'Publication' instance expected, got <Article: Django lets you create web " "apps easily>" ) with self.assertRaisesMessage(TypeError, msg): with transaction.atomic(): a6.publications.add(a5) # Add a Publication directly via publications.add by using keyword arguments. p5 = a6.publications.create(title="Highlights for Adults") self.assertSequenceEqual( a6.publications.all(), [p5, self.p2, self.p3, self.p1], ) def test_add_remove_set_by_pk(self): a5 = Article.objects.create(headline="Django lets you create web apps easily") a5.publications.add(self.p1.pk) self.assertSequenceEqual(a5.publications.all(), [self.p1]) a5.publications.set([self.p2.pk]) self.assertSequenceEqual(a5.publications.all(), [self.p2]) a5.publications.remove(self.p2.pk) self.assertSequenceEqual(a5.publications.all(), []) def test_add_remove_set_by_to_field(self): user_1 = User.objects.create(username="Jean") user_2 = User.objects.create(username="Joe") a5 = Article.objects.create(headline="Django lets you create web apps easily") a5.authors.add(user_1.username) self.assertSequenceEqual(a5.authors.all(), [user_1]) a5.authors.set([user_2.username]) self.assertSequenceEqual(a5.authors.all(), [user_2]) a5.authors.remove(user_2.username) self.assertSequenceEqual(a5.authors.all(), []) def test_add_remove_invalid_type(self): msg = "Field 'id' expected a number but got 'invalid'." for method in ["add", "remove"]: with self.subTest(method), self.assertRaisesMessage(ValueError, msg): getattr(self.a1.publications, method)("invalid") def test_reverse_add(self): # Adding via the 'other' end of an m2m a5 = Article(headline="NASA finds intelligent life on Mars") a5.save() self.p2.article_set.add(a5) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, a5, self.a2, self.a4], ) self.assertSequenceEqual(a5.publications.all(), [self.p2]) # Adding via the other end using keywords a6 = self.p2.article_set.create(headline="Carbon-free diet works wonders") self.assertSequenceEqual( self.p2.article_set.all(), [a6, self.a3, a5, self.a2, self.a4], ) a6 = self.p2.article_set.all()[3] self.assertSequenceEqual( a6.publications.all(), [self.p4, self.p2, self.p3, self.p1], ) @skipUnlessDBFeature("supports_ignore_conflicts") def test_fast_add_ignore_conflicts(self): """ A single query is necessary to add auto-created through instances if the database backend supports bulk_create(ignore_conflicts) and no m2m_changed signals receivers are connected. """ with self.assertNumQueries(1): self.a1.publications.add(self.p1, self.p2) @skipIfDBFeature("supports_ignore_conflicts") def test_add_existing_different_type(self): # A single SELECT query is necessary to compare existing values to the # provided one; no INSERT should be attempted. with self.assertNumQueries(1): self.a1.publications.add(str(self.p1.pk)) self.assertEqual(self.a1.publications.get(), self.p1) @skipUnlessDBFeature("supports_ignore_conflicts") def test_slow_add_ignore_conflicts(self): manager_cls = self.a1.publications.__class__ # Simulate a race condition between the missing ids retrieval and # the bulk insertion attempt. missing_target_ids = {self.p1.id} # Disable fast-add to test the case where the slow add path is taken. add_plan = (True, False, False) with mock.patch.object( manager_cls, "_get_missing_target_ids", return_value=missing_target_ids ) as mocked: with mock.patch.object(manager_cls, "_get_add_plan", return_value=add_plan): self.a1.publications.add(self.p1) mocked.assert_called_once() def test_related_sets(self): # Article objects have access to their related Publication objects. self.assertSequenceEqual(self.a1.publications.all(), [self.p1]) self.assertSequenceEqual( self.a2.publications.all(), [self.p4, self.p2, self.p3, self.p1], ) # Publication objects have access to their related Article objects. self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a2, self.a4], ) self.assertSequenceEqual( self.p1.article_set.all(), [self.a1, self.a2], ) self.assertSequenceEqual( Publication.objects.get(id=self.p4.id).article_set.all(), [self.a2], ) def test_selects(self): # We can perform kwarg queries across m2m relationships self.assertSequenceEqual( Article.objects.filter(publications__id__exact=self.p1.id), [self.a1, self.a2], ) self.assertSequenceEqual( Article.objects.filter(publications__pk=self.p1.id), [self.a1, self.a2], ) self.assertSequenceEqual( Article.objects.filter(publications=self.p1.id), [self.a1, self.a2], ) self.assertSequenceEqual( Article.objects.filter(publications=self.p1), [self.a1, self.a2], ) self.assertSequenceEqual( Article.objects.filter(publications__title__startswith="Science"), [self.a3, self.a2, self.a2, self.a4], ) self.assertSequenceEqual( Article.objects.filter( publications__title__startswith="Science" ).distinct(), [self.a3, self.a2, self.a4], ) # The count() function respects distinct() as well. self.assertEqual( Article.objects.filter(publications__title__startswith="Science").count(), 4 ) self.assertEqual( Article.objects.filter(publications__title__startswith="Science") .distinct() .count(), 3, ) self.assertSequenceEqual( Article.objects.filter( publications__in=[self.p1.id, self.p2.id] ).distinct(), [self.a1, self.a3, self.a2, self.a4], ) self.assertSequenceEqual( Article.objects.filter(publications__in=[self.p1.id, self.p2]).distinct(), [self.a1, self.a3, self.a2, self.a4], ) self.assertSequenceEqual( Article.objects.filter(publications__in=[self.p1, self.p2]).distinct(), [self.a1, self.a3, self.a2, self.a4], ) # Excluding a related item works as you would expect, too (although the SQL # involved is a little complex). self.assertSequenceEqual( Article.objects.exclude(publications=self.p2), [self.a1], ) def test_reverse_selects(self): # Reverse m2m queries are supported (i.e., starting at the table that # doesn't have a ManyToManyField). python_journal = [self.p1] self.assertSequenceEqual( Publication.objects.filter(id__exact=self.p1.id), python_journal ) self.assertSequenceEqual( Publication.objects.filter(pk=self.p1.id), python_journal ) self.assertSequenceEqual( Publication.objects.filter(article__headline__startswith="NASA"), [self.p4, self.p2, self.p2, self.p3, self.p1], ) self.assertSequenceEqual( Publication.objects.filter(article__id__exact=self.a1.id), python_journal ) self.assertSequenceEqual( Publication.objects.filter(article__pk=self.a1.id), python_journal ) self.assertSequenceEqual( Publication.objects.filter(article=self.a1.id), python_journal ) self.assertSequenceEqual( Publication.objects.filter(article=self.a1), python_journal ) self.assertSequenceEqual( Publication.objects.filter(article__in=[self.a1.id, self.a2.id]).distinct(), [self.p4, self.p2, self.p3, self.p1], ) self.assertSequenceEqual( Publication.objects.filter(article__in=[self.a1.id, self.a2]).distinct(), [self.p4, self.p2, self.p3, self.p1], ) self.assertSequenceEqual( Publication.objects.filter(article__in=[self.a1, self.a2]).distinct(), [self.p4, self.p2, self.p3, self.p1], ) def test_delete(self): # If we delete a Publication, its Articles won't be able to access it. self.p1.delete() self.assertSequenceEqual( Publication.objects.all(), [self.p4, self.p2, self.p3], ) self.assertSequenceEqual(self.a1.publications.all(), []) # If we delete an Article, its Publications won't be able to access it. self.a2.delete() self.assertSequenceEqual( Article.objects.all(), [self.a1, self.a3, self.a4], ) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) def test_bulk_delete(self): # Bulk delete some Publications - references to deleted publications should go Publication.objects.filter(title__startswith="Science").delete() self.assertSequenceEqual( Publication.objects.all(), [self.p4, self.p1], ) self.assertSequenceEqual( Article.objects.all(), [self.a1, self.a3, self.a2, self.a4], ) self.assertSequenceEqual( self.a2.publications.all(), [self.p4, self.p1], ) # Bulk delete some articles - references to deleted objects should go q = Article.objects.filter(headline__startswith="Django") self.assertSequenceEqual(q, [self.a1]) q.delete() # After the delete, the QuerySet cache needs to be cleared, # and the referenced objects should be gone self.assertSequenceEqual(q, []) self.assertSequenceEqual(self.p1.article_set.all(), [self.a2]) def test_remove(self): # Removing publication from an article: self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a2, self.a4], ) self.a4.publications.remove(self.p2) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a2], ) self.assertSequenceEqual(self.a4.publications.all(), []) # And from the other end self.p2.article_set.remove(self.a3) self.assertSequenceEqual(self.p2.article_set.all(), [self.a2]) self.assertSequenceEqual(self.a3.publications.all(), []) def test_set(self): self.p2.article_set.set([self.a4, self.a3]) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) self.assertSequenceEqual(self.a4.publications.all(), [self.p3]) self.p2.article_set.set([]) self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([]) self.assertSequenceEqual(self.a4.publications.all(), []) self.p2.article_set.set([self.a4, self.a3], clear=True) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id], clear=True) self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) self.assertSequenceEqual(self.a4.publications.all(), [self.p3]) self.p2.article_set.set([], clear=True) self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([], clear=True) self.assertSequenceEqual(self.a4.publications.all(), []) def test_set_existing_different_type(self): # Existing many-to-many relations remain the same for values provided # with a different type. ids = set( Publication.article_set.through.objects.filter( article__in=[self.a4, self.a3], publication=self.p2, ).values_list("id", flat=True) ) self.p2.article_set.set([str(self.a4.pk), str(self.a3.pk)]) new_ids = set( Publication.article_set.through.objects.filter( publication=self.p2, ).values_list("id", flat=True) ) self.assertEqual(ids, new_ids) def test_assign_forward(self): msg = ( "Direct assignment to the reverse side of a many-to-many set is " "prohibited. Use article_set.set() instead." ) with self.assertRaisesMessage(TypeError, msg): self.p2.article_set = [self.a4, self.a3] def test_assign_reverse(self): msg = ( "Direct assignment to the forward side of a many-to-many " "set is prohibited. Use publications.set() instead." ) with self.assertRaisesMessage(TypeError, msg): self.a1.publications = [self.p1, self.p2] def test_assign(self): # Relation sets can be assigned using set(). self.p2.article_set.set([self.a4, self.a3]) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) self.assertSequenceEqual(self.a4.publications.all(), [self.p3]) # An alternate to calling clear() is to set an empty set. self.p2.article_set.set([]) self.assertSequenceEqual(self.p2.article_set.all(), []) self.a4.publications.set([]) self.assertSequenceEqual(self.a4.publications.all(), []) def test_assign_ids(self): # Relation sets can also be set using primary key values self.p2.article_set.set([self.a4.id, self.a3.id]) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.set([self.p3.id]) self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) self.assertSequenceEqual(self.a4.publications.all(), [self.p3]) def test_forward_assign_with_queryset(self): # Querysets used in m2m assignments are pre-evaluated so their value # isn't affected by the clearing operation in ManyRelatedManager.set() # (#19816). self.a1.publications.set([self.p1, self.p2]) qs = self.a1.publications.filter(title="The Python Journal") self.a1.publications.set(qs) self.assertEqual(1, self.a1.publications.count()) self.assertEqual(1, qs.count()) def test_reverse_assign_with_queryset(self): # Querysets used in M2M assignments are pre-evaluated so their value # isn't affected by the clearing operation in ManyRelatedManager.set() # (#19816). self.p1.article_set.set([self.a1, self.a2]) qs = self.p1.article_set.filter( headline="Django lets you build web apps easily" ) self.p1.article_set.set(qs) self.assertEqual(1, self.p1.article_set.count()) self.assertEqual(1, qs.count()) def test_clear(self): # Relation sets can be cleared: self.p2.article_set.clear() self.assertSequenceEqual(self.p2.article_set.all(), []) self.assertSequenceEqual(self.a4.publications.all(), []) # And you can clear from the other end self.p2.article_set.add(self.a3, self.a4) self.assertSequenceEqual( self.p2.article_set.all(), [self.a3, self.a4], ) self.assertSequenceEqual(self.a4.publications.all(), [self.p2]) self.a4.publications.clear() self.assertSequenceEqual(self.a4.publications.all(), []) self.assertSequenceEqual(self.p2.article_set.all(), [self.a3]) def test_clear_after_prefetch(self): a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id) self.assertSequenceEqual(a4.publications.all(), [self.p2]) a4.publications.clear() self.assertSequenceEqual(a4.publications.all(), []) def test_remove_after_prefetch(self): a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id) self.assertSequenceEqual(a4.publications.all(), [self.p2]) a4.publications.remove(self.p2) self.assertSequenceEqual(a4.publications.all(), []) def test_add_after_prefetch(self): a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id) self.assertEqual(a4.publications.count(), 1) a4.publications.add(self.p1) self.assertEqual(a4.publications.count(), 2) def test_set_after_prefetch(self): a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id) self.assertEqual(a4.publications.count(), 1) a4.publications.set([self.p2, self.p1]) self.assertEqual(a4.publications.count(), 2) a4.publications.set([self.p1]) self.assertEqual(a4.publications.count(), 1) def test_add_then_remove_after_prefetch(self): a4 = Article.objects.prefetch_related("publications").get(id=self.a4.id) self.assertEqual(a4.publications.count(), 1) a4.publications.add(self.p1) self.assertEqual(a4.publications.count(), 2) a4.publications.remove(self.p1) self.assertSequenceEqual(a4.publications.all(), [self.p2]) def test_inherited_models_selects(self): """ #24156 - Objects from child models where the parent's m2m field uses related_name='+' should be retrieved correctly. """ a = InheritedArticleA.objects.create() b = InheritedArticleB.objects.create() a.publications.add(self.p1, self.p2) self.assertSequenceEqual( a.publications.all(), [self.p2, self.p1], ) self.assertSequenceEqual(b.publications.all(), []) b.publications.add(self.p3) self.assertSequenceEqual( a.publications.all(), [self.p2, self.p1], ) self.assertSequenceEqual(b.publications.all(), [self.p3]) def test_custom_default_manager_exists_count(self): a5 = Article.objects.create(headline="deleted") a5.publications.add(self.p2) self.assertEqual(self.p2.article_set.count(), self.p2.article_set.all().count()) self.assertEqual( self.p3.article_set.exists(), self.p3.article_set.all().exists() )
9709228015091c9597c11b4de797631af3f5da8c1287c899fad4a987c746c089
""" Many-to-many relationships To define a many-to-many relationship, use ``ManyToManyField()``. In this example, an ``Article`` can be published in multiple ``Publication`` objects, and a ``Publication`` has multiple ``Article`` objects. """ from django.db import models class Publication(models.Model): title = models.CharField(max_length=30) class Meta: ordering = ("title",) def __str__(self): return self.title class Tag(models.Model): id = models.BigAutoField(primary_key=True) name = models.CharField(max_length=50) def __str__(self): return self.name class NoDeletedArticleManager(models.Manager): def get_queryset(self): return super().get_queryset().exclude(headline="deleted") class Article(models.Model): headline = models.CharField(max_length=100) # Assign a string as name to make sure the intermediary model is # correctly created. Refs #20207 publications = models.ManyToManyField(Publication, name="publications") tags = models.ManyToManyField(Tag, related_name="tags") authors = models.ManyToManyField("User", through="UserArticle") objects = NoDeletedArticleManager() class Meta: ordering = ("headline",) def __str__(self): return self.headline class User(models.Model): username = models.CharField(max_length=20, unique=True) def __str__(self): return self.username class UserArticle(models.Model): user = models.ForeignKey(User, models.CASCADE, to_field="username") article = models.ForeignKey(Article, models.CASCADE) # Models to test correct related_name inheritance class AbstractArticle(models.Model): class Meta: abstract = True publications = models.ManyToManyField( Publication, name="publications", related_name="+" ) class InheritedArticleA(AbstractArticle): pass class InheritedArticleB(AbstractArticle): pass
ab2bef70c9db4c56ad9f20dc66e6f1f8a2975e7b5a98773ad2bed3b2bc3c10c1
from io import BytesIO from django.core.exceptions import RequestDataTooBig, TooManyFieldsSent from django.core.handlers.wsgi import WSGIRequest from django.test import SimpleTestCase from django.test.client import FakePayload TOO_MANY_FIELDS_MSG = ( "The number of GET/POST parameters exceeded settings.DATA_UPLOAD_MAX_NUMBER_FIELDS." ) TOO_MUCH_DATA_MSG = "Request body exceeded settings.DATA_UPLOAD_MAX_MEMORY_SIZE." class DataUploadMaxMemorySizeFormPostTests(SimpleTestCase): def setUp(self): payload = FakePayload("a=1&a=2&a=3\r\n") self.request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) def test_size_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=12): with self.assertRaisesMessage(RequestDataTooBig, TOO_MUCH_DATA_MSG): self.request._load_post_and_files() def test_size_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=13): self.request._load_post_and_files() def test_no_limit(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=None): self.request._load_post_and_files() class DataUploadMaxMemorySizeMultipartPostTests(SimpleTestCase): def setUp(self): payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name"', "", "value", "--boundary--", ] ) ) self.request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) def test_size_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=10): with self.assertRaisesMessage(RequestDataTooBig, TOO_MUCH_DATA_MSG): self.request._load_post_and_files() def test_size_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=11): self.request._load_post_and_files() def test_no_limit(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=None): self.request._load_post_and_files() def test_file_passes(self): payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="file1"; ' 'filename="test.file"', "", "value", "--boundary--", ] ) ) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=1): request._load_post_and_files() self.assertIn("file1", request.FILES, "Upload file not present") class DataUploadMaxMemorySizeGetTests(SimpleTestCase): def setUp(self): self.request = WSGIRequest( { "REQUEST_METHOD": "GET", "wsgi.input": BytesIO(b""), "CONTENT_LENGTH": 3, } ) def test_data_upload_max_memory_size_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=2): with self.assertRaisesMessage(RequestDataTooBig, TOO_MUCH_DATA_MSG): self.request.body def test_size_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=3): self.request.body def test_no_limit(self): with self.settings(DATA_UPLOAD_MAX_MEMORY_SIZE=None): self.request.body def test_empty_content_length(self): self.request.environ["CONTENT_LENGTH"] = "" self.request.body class DataUploadMaxNumberOfFieldsGet(SimpleTestCase): def test_get_max_fields_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=1): with self.assertRaisesMessage(TooManyFieldsSent, TOO_MANY_FIELDS_MSG): request = WSGIRequest( { "REQUEST_METHOD": "GET", "wsgi.input": BytesIO(b""), "QUERY_STRING": "a=1&a=2&a=3", } ) request.GET["a"] def test_get_max_fields_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=3): request = WSGIRequest( { "REQUEST_METHOD": "GET", "wsgi.input": BytesIO(b""), "QUERY_STRING": "a=1&a=2&a=3", } ) request.GET["a"] class DataUploadMaxNumberOfFieldsMultipartPost(SimpleTestCase): def setUp(self): payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name1"', "", "value1", "--boundary", 'Content-Disposition: form-data; name="name2"', "", "value2", "--boundary--", ] ) ) self.request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) def test_number_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=1): with self.assertRaisesMessage(TooManyFieldsSent, TOO_MANY_FIELDS_MSG): self.request._load_post_and_files() def test_number_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=2): self.request._load_post_and_files() def test_no_limit(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=None): self.request._load_post_and_files() class DataUploadMaxNumberOfFieldsFormPost(SimpleTestCase): def setUp(self): payload = FakePayload("\r\n".join(["a=1&a=2&a=3", ""])) self.request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) def test_number_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=2): with self.assertRaisesMessage(TooManyFieldsSent, TOO_MANY_FIELDS_MSG): self.request._load_post_and_files() def test_number_not_exceeded(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=3): self.request._load_post_and_files() def test_no_limit(self): with self.settings(DATA_UPLOAD_MAX_NUMBER_FIELDS=None): self.request._load_post_and_files()
1c37bb17f2abaecfa00c6eb4da58b710dbb0f9aec0b685aa996444021b97e521
from io import BytesIO from itertools import chain from urllib.parse import urlencode from django.core.exceptions import DisallowedHost from django.core.handlers.wsgi import LimitedStream, WSGIRequest from django.http import HttpRequest, RawPostDataException, UnreadablePostError from django.http.multipartparser import MultiPartParserError from django.http.request import HttpHeaders, split_domain_port from django.test import RequestFactory, SimpleTestCase, override_settings from django.test.client import FakePayload class RequestsTests(SimpleTestCase): def test_httprequest(self): request = HttpRequest() self.assertEqual(list(request.GET), []) self.assertEqual(list(request.POST), []) self.assertEqual(list(request.COOKIES), []) self.assertEqual(list(request.META), []) # .GET and .POST should be QueryDicts self.assertEqual(request.GET.urlencode(), "") self.assertEqual(request.POST.urlencode(), "") # and FILES should be MultiValueDict self.assertEqual(request.FILES.getlist("foo"), []) self.assertIsNone(request.content_type) self.assertIsNone(request.content_params) def test_httprequest_full_path(self): request = HttpRequest() request.path = "/;some/?awful/=path/foo:bar/" request.path_info = "/prefix" + request.path request.META["QUERY_STRING"] = ";some=query&+query=string" expected = "/%3Bsome/%3Fawful/%3Dpath/foo:bar/?;some=query&+query=string" self.assertEqual(request.get_full_path(), expected) self.assertEqual(request.get_full_path_info(), "/prefix" + expected) def test_httprequest_full_path_with_query_string_and_fragment(self): request = HttpRequest() request.path = "/foo#bar" request.path_info = "/prefix" + request.path request.META["QUERY_STRING"] = "baz#quux" self.assertEqual(request.get_full_path(), "/foo%23bar?baz#quux") self.assertEqual(request.get_full_path_info(), "/prefix/foo%23bar?baz#quux") def test_httprequest_repr(self): request = HttpRequest() request.path = "/somepath/" request.method = "GET" request.GET = {"get-key": "get-value"} request.POST = {"post-key": "post-value"} request.COOKIES = {"post-key": "post-value"} request.META = {"post-key": "post-value"} self.assertEqual(repr(request), "<HttpRequest: GET '/somepath/'>") def test_httprequest_repr_invalid_method_and_path(self): request = HttpRequest() self.assertEqual(repr(request), "<HttpRequest>") request = HttpRequest() request.method = "GET" self.assertEqual(repr(request), "<HttpRequest>") request = HttpRequest() request.path = "" self.assertEqual(repr(request), "<HttpRequest>") def test_wsgirequest(self): request = WSGIRequest( { "PATH_INFO": "bogus", "REQUEST_METHOD": "bogus", "CONTENT_TYPE": "text/html; charset=utf8", "wsgi.input": BytesIO(b""), } ) self.assertEqual(list(request.GET), []) self.assertEqual(list(request.POST), []) self.assertEqual(list(request.COOKIES), []) self.assertEqual( set(request.META), { "PATH_INFO", "REQUEST_METHOD", "SCRIPT_NAME", "CONTENT_TYPE", "wsgi.input", }, ) self.assertEqual(request.META["PATH_INFO"], "bogus") self.assertEqual(request.META["REQUEST_METHOD"], "bogus") self.assertEqual(request.META["SCRIPT_NAME"], "") self.assertEqual(request.content_type, "text/html") self.assertEqual(request.content_params, {"charset": "utf8"}) def test_wsgirequest_with_script_name(self): """ The request's path is correctly assembled, regardless of whether or not the SCRIPT_NAME has a trailing slash (#20169). """ # With trailing slash request = WSGIRequest( { "PATH_INFO": "/somepath/", "SCRIPT_NAME": "/PREFIX/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/PREFIX/somepath/") # Without trailing slash request = WSGIRequest( { "PATH_INFO": "/somepath/", "SCRIPT_NAME": "/PREFIX", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/PREFIX/somepath/") def test_wsgirequest_script_url_double_slashes(self): """ WSGI squashes multiple successive slashes in PATH_INFO, WSGIRequest should take that into account when populating request.path and request.META['SCRIPT_NAME'] (#17133). """ request = WSGIRequest( { "SCRIPT_URL": "/mst/milestones//accounts/login//help", "PATH_INFO": "/milestones/accounts/login/help", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/mst/milestones/accounts/login/help") self.assertEqual(request.META["SCRIPT_NAME"], "/mst") def test_wsgirequest_with_force_script_name(self): """ The FORCE_SCRIPT_NAME setting takes precedence over the request's SCRIPT_NAME environment parameter (#20169). """ with override_settings(FORCE_SCRIPT_NAME="/FORCED_PREFIX/"): request = WSGIRequest( { "PATH_INFO": "/somepath/", "SCRIPT_NAME": "/PREFIX/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/FORCED_PREFIX/somepath/") def test_wsgirequest_path_with_force_script_name_trailing_slash(self): """ The request's path is correctly assembled, regardless of whether or not the FORCE_SCRIPT_NAME setting has a trailing slash (#20169). """ # With trailing slash with override_settings(FORCE_SCRIPT_NAME="/FORCED_PREFIX/"): request = WSGIRequest( { "PATH_INFO": "/somepath/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/FORCED_PREFIX/somepath/") # Without trailing slash with override_settings(FORCE_SCRIPT_NAME="/FORCED_PREFIX"): request = WSGIRequest( { "PATH_INFO": "/somepath/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/FORCED_PREFIX/somepath/") def test_wsgirequest_repr(self): request = WSGIRequest({"REQUEST_METHOD": "get", "wsgi.input": BytesIO(b"")}) self.assertEqual(repr(request), "<WSGIRequest: GET '/'>") request = WSGIRequest( { "PATH_INFO": "/somepath/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) request.GET = {"get-key": "get-value"} request.POST = {"post-key": "post-value"} request.COOKIES = {"post-key": "post-value"} request.META = {"post-key": "post-value"} self.assertEqual(repr(request), "<WSGIRequest: GET '/somepath/'>") def test_wsgirequest_path_info(self): def wsgi_str(path_info, encoding="utf-8"): path_info = path_info.encode( encoding ) # Actual URL sent by the browser (bytestring) path_info = path_info.decode( "iso-8859-1" ) # Value in the WSGI environ dict (native string) return path_info # Regression for #19468 request = WSGIRequest( { "PATH_INFO": wsgi_str("/سلام/"), "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) self.assertEqual(request.path, "/سلام/") # The URL may be incorrectly encoded in a non-UTF-8 encoding (#26971) request = WSGIRequest( { "PATH_INFO": wsgi_str("/café/", encoding="iso-8859-1"), "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), } ) # Since it's impossible to decide the (wrong) encoding of the URL, it's # left percent-encoded in the path. self.assertEqual(request.path, "/caf%E9/") def test_limited_stream(self): # Read all of a limited stream stream = LimitedStream(BytesIO(b"test"), 2) self.assertEqual(stream.read(), b"te") # Reading again returns nothing. self.assertEqual(stream.read(), b"") # Read a number of characters greater than the stream has to offer stream = LimitedStream(BytesIO(b"test"), 2) self.assertEqual(stream.read(5), b"te") # Reading again returns nothing. self.assertEqual(stream.readline(5), b"") # Read sequentially from a stream stream = LimitedStream(BytesIO(b"12345678"), 8) self.assertEqual(stream.read(5), b"12345") self.assertEqual(stream.read(5), b"678") # Reading again returns nothing. self.assertEqual(stream.readline(5), b"") # Read lines from a stream stream = LimitedStream(BytesIO(b"1234\n5678\nabcd\nefgh\nijkl"), 24) # Read a full line, unconditionally self.assertEqual(stream.readline(), b"1234\n") # Read a number of characters less than a line self.assertEqual(stream.readline(2), b"56") # Read the rest of the partial line self.assertEqual(stream.readline(), b"78\n") # Read a full line, with a character limit greater than the line length self.assertEqual(stream.readline(6), b"abcd\n") # Read the next line, deliberately terminated at the line end self.assertEqual(stream.readline(4), b"efgh") # Read the next line... just the line end self.assertEqual(stream.readline(), b"\n") # Read everything else. self.assertEqual(stream.readline(), b"ijkl") # Regression for #15018 # If a stream contains a newline, but the provided length # is less than the number of provided characters, the newline # doesn't reset the available character count stream = LimitedStream(BytesIO(b"1234\nabcdef"), 9) self.assertEqual(stream.readline(10), b"1234\n") self.assertEqual(stream.readline(3), b"abc") # Now expire the available characters self.assertEqual(stream.readline(3), b"d") # Reading again returns nothing. self.assertEqual(stream.readline(2), b"") # Same test, but with read, not readline. stream = LimitedStream(BytesIO(b"1234\nabcdef"), 9) self.assertEqual(stream.read(6), b"1234\na") self.assertEqual(stream.read(2), b"bc") self.assertEqual(stream.read(2), b"d") self.assertEqual(stream.read(2), b"") self.assertEqual(stream.read(), b"") def test_stream(self): payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, }, ) self.assertEqual(request.read(), b"name=value") def test_read_after_value(self): """ Reading from request is allowed after accessing request contents as POST or body. """ payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(request.POST, {"name": ["value"]}) self.assertEqual(request.body, b"name=value") self.assertEqual(request.read(), b"name=value") def test_value_after_read(self): """ Construction of POST or body is not allowed after reading from request. """ payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(request.read(2), b"na") with self.assertRaises(RawPostDataException): request.body self.assertEqual(request.POST, {}) def test_non_ascii_POST(self): payload = FakePayload(urlencode({"key": "España"})) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_LENGTH": len(payload), "CONTENT_TYPE": "application/x-www-form-urlencoded", "wsgi.input": payload, } ) self.assertEqual(request.POST, {"key": ["España"]}) def test_alternate_charset_POST(self): """ Test a POST with non-utf-8 payload encoding. """ payload = FakePayload(urlencode({"key": "España".encode("latin-1")})) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_LENGTH": len(payload), "CONTENT_TYPE": "application/x-www-form-urlencoded; charset=iso-8859-1", "wsgi.input": payload, } ) self.assertEqual(request.POST, {"key": ["España"]}) def test_body_after_POST_multipart_form_data(self): """ Reading body after parsing multipart/form-data is not allowed """ # Because multipart is used for large amounts of data i.e. file uploads, # we don't want the data held in memory twice, and we don't want to # silence the error by setting body = '' either. payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name"', "", "value", "--boundary--", ] ) ) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(request.POST, {"name": ["value"]}) with self.assertRaises(RawPostDataException): request.body def test_body_after_POST_multipart_related(self): """ Reading body after parsing multipart that isn't form-data is allowed """ # Ticket #9054 # There are cases in which the multipart data is related instead of # being a binary upload, in which case it should still be accessible # via body. payload_data = b"\r\n".join( [ b"--boundary", b'Content-ID: id; name="name"', b"", b"value", b"--boundary--", ] ) payload = FakePayload(payload_data) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/related; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(request.POST, {}) self.assertEqual(request.body, payload_data) def test_POST_multipart_with_content_length_zero(self): """ Multipart POST requests with Content-Length >= 0 are valid and need to be handled. """ # According to: # https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.13 # Every request.POST with Content-Length >= 0 is a valid request, # this test ensures that we handle Content-Length == 0. payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name"', "", "value", "--boundary--", ] ) ) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": 0, "wsgi.input": payload, } ) self.assertEqual(request.POST, {}) def test_POST_binary_only(self): payload = b"\r\n\x01\x00\x00\x00ab\x00\x00\xcd\xcc,@" environ = { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/octet-stream", "CONTENT_LENGTH": len(payload), "wsgi.input": BytesIO(payload), } request = WSGIRequest(environ) self.assertEqual(request.POST, {}) self.assertEqual(request.FILES, {}) self.assertEqual(request.body, payload) # Same test without specifying content-type environ.update({"CONTENT_TYPE": "", "wsgi.input": BytesIO(payload)}) request = WSGIRequest(environ) self.assertEqual(request.POST, {}) self.assertEqual(request.FILES, {}) self.assertEqual(request.body, payload) def test_read_by_lines(self): payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(list(request), [b"name=value"]) def test_POST_after_body_read(self): """ POST should be populated even if body is read first """ payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) request.body # evaluate self.assertEqual(request.POST, {"name": ["value"]}) def test_POST_after_body_read_and_stream_read(self): """ POST should be populated even if body is read first, and then the stream is read second. """ payload = FakePayload("name=value") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) request.body # evaluate self.assertEqual(request.read(1), b"n") self.assertEqual(request.POST, {"name": ["value"]}) def test_POST_after_body_read_and_stream_read_multipart(self): """ POST should be populated even if body is read first, and then the stream is read second. Using multipart/form-data instead of urlencoded. """ payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name"', "", "value", "--boundary--" "", ] ) ) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) request.body # evaluate # Consume enough data to mess up the parsing: self.assertEqual(request.read(13), b"--boundary\r\nC") self.assertEqual(request.POST, {"name": ["value"]}) def test_POST_immutable_for_multipart(self): """ MultiPartParser.parse() leaves request.POST immutable. """ payload = FakePayload( "\r\n".join( [ "--boundary", 'Content-Disposition: form-data; name="name"', "", "value", "--boundary--", ] ) ) request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=boundary", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertFalse(request.POST._mutable) def test_multipart_without_boundary(self): request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data;", "CONTENT_LENGTH": 0, "wsgi.input": FakePayload(), } ) with self.assertRaisesMessage( MultiPartParserError, "Invalid boundary in multipart: None" ): request.POST def test_multipart_non_ascii_content_type(self): request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary = \xe0", "CONTENT_LENGTH": 0, "wsgi.input": FakePayload(), } ) msg = ( "Invalid non-ASCII Content-Type in multipart: multipart/form-data; " "boundary = à" ) with self.assertRaisesMessage(MultiPartParserError, msg): request.POST def test_POST_connection_error(self): """ If wsgi.input.read() raises an exception while trying to read() the POST, the exception is identifiable (not a generic OSError). """ class ExplodingBytesIO(BytesIO): def read(self, len=0): raise OSError("kaboom!") payload = b"name=value" request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": ExplodingBytesIO(payload), } ) with self.assertRaises(UnreadablePostError): request.body def test_set_encoding_clears_POST(self): payload = FakePayload("name=Hello Günter") request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded", "CONTENT_LENGTH": len(payload), "wsgi.input": payload, } ) self.assertEqual(request.POST, {"name": ["Hello Günter"]}) request.encoding = "iso-8859-16" self.assertEqual(request.POST, {"name": ["Hello GĂŒnter"]}) def test_set_encoding_clears_GET(self): request = WSGIRequest( { "REQUEST_METHOD": "GET", "wsgi.input": "", "QUERY_STRING": "name=Hello%20G%C3%BCnter", } ) self.assertEqual(request.GET, {"name": ["Hello Günter"]}) request.encoding = "iso-8859-16" self.assertEqual(request.GET, {"name": ["Hello G\u0102\u0152nter"]}) def test_FILES_connection_error(self): """ If wsgi.input.read() raises an exception while trying to read() the FILES, the exception is identifiable (not a generic OSError). """ class ExplodingBytesIO(BytesIO): def read(self, len=0): raise OSError("kaboom!") payload = b"x" request = WSGIRequest( { "REQUEST_METHOD": "POST", "CONTENT_TYPE": "multipart/form-data; boundary=foo_", "CONTENT_LENGTH": len(payload), "wsgi.input": ExplodingBytesIO(payload), } ) with self.assertRaises(UnreadablePostError): request.FILES class HostValidationTests(SimpleTestCase): poisoned_hosts = [ "[email protected]", "example.com:[email protected]", "example.com:[email protected]:80", "example.com:80/badpath", "example.com: recovermypassword.com", ] @override_settings( USE_X_FORWARDED_HOST=False, ALLOWED_HOSTS=[ "forward.com", "example.com", "internal.com", "12.34.56.78", "[2001:19f0:feee::dead:beef:cafe]", "xn--4ca9at.com", ".multitenant.com", "INSENSITIVE.com", "[::ffff:169.254.169.254]", ], ) def test_http_get_host(self): # Check if X_FORWARDED_HOST is provided. request = HttpRequest() request.META = { "HTTP_X_FORWARDED_HOST": "forward.com", "HTTP_HOST": "example.com", "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } # X_FORWARDED_HOST is ignored. self.assertEqual(request.get_host(), "example.com") # Check if X_FORWARDED_HOST isn't provided. request = HttpRequest() request.META = { "HTTP_HOST": "example.com", "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } self.assertEqual(request.get_host(), "example.com") # Check if HTTP_HOST isn't provided. request = HttpRequest() request.META = { "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } self.assertEqual(request.get_host(), "internal.com") # Check if HTTP_HOST isn't provided, and we're on a nonstandard port request = HttpRequest() request.META = { "SERVER_NAME": "internal.com", "SERVER_PORT": 8042, } self.assertEqual(request.get_host(), "internal.com:8042") legit_hosts = [ "example.com", "example.com:80", "12.34.56.78", "12.34.56.78:443", "[2001:19f0:feee::dead:beef:cafe]", "[2001:19f0:feee::dead:beef:cafe]:8080", "xn--4ca9at.com", # Punycode for öäü.com "anything.multitenant.com", "multitenant.com", "insensitive.com", "example.com.", "example.com.:80", "[::ffff:169.254.169.254]", ] for host in legit_hosts: request = HttpRequest() request.META = { "HTTP_HOST": host, } request.get_host() # Poisoned host headers are rejected as suspicious for host in chain(self.poisoned_hosts, ["other.com", "example.com.."]): with self.assertRaises(DisallowedHost): request = HttpRequest() request.META = { "HTTP_HOST": host, } request.get_host() @override_settings(USE_X_FORWARDED_HOST=True, ALLOWED_HOSTS=["*"]) def test_http_get_host_with_x_forwarded_host(self): # Check if X_FORWARDED_HOST is provided. request = HttpRequest() request.META = { "HTTP_X_FORWARDED_HOST": "forward.com", "HTTP_HOST": "example.com", "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } # X_FORWARDED_HOST is obeyed. self.assertEqual(request.get_host(), "forward.com") # Check if X_FORWARDED_HOST isn't provided. request = HttpRequest() request.META = { "HTTP_HOST": "example.com", "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } self.assertEqual(request.get_host(), "example.com") # Check if HTTP_HOST isn't provided. request = HttpRequest() request.META = { "SERVER_NAME": "internal.com", "SERVER_PORT": 80, } self.assertEqual(request.get_host(), "internal.com") # Check if HTTP_HOST isn't provided, and we're on a nonstandard port request = HttpRequest() request.META = { "SERVER_NAME": "internal.com", "SERVER_PORT": 8042, } self.assertEqual(request.get_host(), "internal.com:8042") # Poisoned host headers are rejected as suspicious legit_hosts = [ "example.com", "example.com:80", "12.34.56.78", "12.34.56.78:443", "[2001:19f0:feee::dead:beef:cafe]", "[2001:19f0:feee::dead:beef:cafe]:8080", "xn--4ca9at.com", # Punycode for öäü.com ] for host in legit_hosts: request = HttpRequest() request.META = { "HTTP_HOST": host, } request.get_host() for host in self.poisoned_hosts: with self.assertRaises(DisallowedHost): request = HttpRequest() request.META = { "HTTP_HOST": host, } request.get_host() @override_settings(USE_X_FORWARDED_PORT=False) def test_get_port(self): request = HttpRequest() request.META = { "SERVER_PORT": "8080", "HTTP_X_FORWARDED_PORT": "80", } # Shouldn't use the X-Forwarded-Port header self.assertEqual(request.get_port(), "8080") request = HttpRequest() request.META = { "SERVER_PORT": "8080", } self.assertEqual(request.get_port(), "8080") @override_settings(USE_X_FORWARDED_PORT=True) def test_get_port_with_x_forwarded_port(self): request = HttpRequest() request.META = { "SERVER_PORT": "8080", "HTTP_X_FORWARDED_PORT": "80", } # Should use the X-Forwarded-Port header self.assertEqual(request.get_port(), "80") request = HttpRequest() request.META = { "SERVER_PORT": "8080", } self.assertEqual(request.get_port(), "8080") @override_settings(DEBUG=True, ALLOWED_HOSTS=[]) def test_host_validation_in_debug_mode(self): """ If ALLOWED_HOSTS is empty and DEBUG is True, variants of localhost are allowed. """ valid_hosts = ["localhost", "subdomain.localhost", "127.0.0.1", "[::1]"] for host in valid_hosts: request = HttpRequest() request.META = {"HTTP_HOST": host} self.assertEqual(request.get_host(), host) # Other hostnames raise a DisallowedHost. with self.assertRaises(DisallowedHost): request = HttpRequest() request.META = {"HTTP_HOST": "example.com"} request.get_host() @override_settings(ALLOWED_HOSTS=[]) def test_get_host_suggestion_of_allowed_host(self): """ get_host() makes helpful suggestions if a valid-looking host is not in ALLOWED_HOSTS. """ msg_invalid_host = "Invalid HTTP_HOST header: %r." msg_suggestion = msg_invalid_host + " You may need to add %r to ALLOWED_HOSTS." msg_suggestion2 = ( msg_invalid_host + " The domain name provided is not valid according to RFC 1034/1035" ) for host in [ # Valid-looking hosts "example.com", "12.34.56.78", "[2001:19f0:feee::dead:beef:cafe]", "xn--4ca9at.com", # Punycode for öäü.com ]: request = HttpRequest() request.META = {"HTTP_HOST": host} with self.assertRaisesMessage( DisallowedHost, msg_suggestion % (host, host) ): request.get_host() for domain, port in [ # Valid-looking hosts with a port number ("example.com", 80), ("12.34.56.78", 443), ("[2001:19f0:feee::dead:beef:cafe]", 8080), ]: host = "%s:%s" % (domain, port) request = HttpRequest() request.META = {"HTTP_HOST": host} with self.assertRaisesMessage( DisallowedHost, msg_suggestion % (host, domain) ): request.get_host() for host in self.poisoned_hosts: request = HttpRequest() request.META = {"HTTP_HOST": host} with self.assertRaisesMessage(DisallowedHost, msg_invalid_host % host): request.get_host() request = HttpRequest() request.META = {"HTTP_HOST": "invalid_hostname.com"} with self.assertRaisesMessage( DisallowedHost, msg_suggestion2 % "invalid_hostname.com" ): request.get_host() def test_split_domain_port_removes_trailing_dot(self): domain, port = split_domain_port("example.com.:8080") self.assertEqual(domain, "example.com") self.assertEqual(port, "8080") class BuildAbsoluteURITests(SimpleTestCase): factory = RequestFactory() def test_absolute_url(self): request = HttpRequest() url = "https://www.example.com/asdf" self.assertEqual(request.build_absolute_uri(location=url), url) def test_host_retrieval(self): request = HttpRequest() request.get_host = lambda: "www.example.com" request.path = "" self.assertEqual( request.build_absolute_uri(location="/path/with:colons"), "http://www.example.com/path/with:colons", ) def test_request_path_begins_with_two_slashes(self): # //// creates a request with a path beginning with // request = self.factory.get("////absolute-uri") tests = ( # location isn't provided (None, "http://testserver//absolute-uri"), # An absolute URL ("http://example.com/?foo=bar", "http://example.com/?foo=bar"), # A schema-relative URL ("//example.com/?foo=bar", "http://example.com/?foo=bar"), # Relative URLs ("/foo/bar/", "http://testserver/foo/bar/"), ("/foo/./bar/", "http://testserver/foo/bar/"), ("/foo/../bar/", "http://testserver/bar/"), ("///foo/bar/", "http://testserver/foo/bar/"), ) for location, expected_url in tests: with self.subTest(location=location): self.assertEqual( request.build_absolute_uri(location=location), expected_url ) class RequestHeadersTests(SimpleTestCase): ENVIRON = { # Non-headers are ignored. "PATH_INFO": "/somepath/", "REQUEST_METHOD": "get", "wsgi.input": BytesIO(b""), "SERVER_NAME": "internal.com", "SERVER_PORT": 80, # These non-HTTP prefixed headers are included. "CONTENT_TYPE": "text/html", "CONTENT_LENGTH": "100", # All HTTP-prefixed headers are included. "HTTP_ACCEPT": "*", "HTTP_HOST": "example.com", "HTTP_USER_AGENT": "python-requests/1.2.0", } def test_base_request_headers(self): request = HttpRequest() request.META = self.ENVIRON self.assertEqual( dict(request.headers), { "Content-Type": "text/html", "Content-Length": "100", "Accept": "*", "Host": "example.com", "User-Agent": "python-requests/1.2.0", }, ) def test_wsgi_request_headers(self): request = WSGIRequest(self.ENVIRON) self.assertEqual( dict(request.headers), { "Content-Type": "text/html", "Content-Length": "100", "Accept": "*", "Host": "example.com", "User-Agent": "python-requests/1.2.0", }, ) def test_wsgi_request_headers_getitem(self): request = WSGIRequest(self.ENVIRON) self.assertEqual(request.headers["User-Agent"], "python-requests/1.2.0") self.assertEqual(request.headers["user-agent"], "python-requests/1.2.0") self.assertEqual(request.headers["user_agent"], "python-requests/1.2.0") self.assertEqual(request.headers["Content-Type"], "text/html") self.assertEqual(request.headers["Content-Length"], "100") def test_wsgi_request_headers_get(self): request = WSGIRequest(self.ENVIRON) self.assertEqual(request.headers.get("User-Agent"), "python-requests/1.2.0") self.assertEqual(request.headers.get("user-agent"), "python-requests/1.2.0") self.assertEqual(request.headers.get("Content-Type"), "text/html") self.assertEqual(request.headers.get("Content-Length"), "100") class HttpHeadersTests(SimpleTestCase): def test_basic(self): environ = { "CONTENT_TYPE": "text/html", "CONTENT_LENGTH": "100", "HTTP_HOST": "example.com", } headers = HttpHeaders(environ) self.assertEqual(sorted(headers), ["Content-Length", "Content-Type", "Host"]) self.assertEqual( headers, { "Content-Type": "text/html", "Content-Length": "100", "Host": "example.com", }, ) def test_parse_header_name(self): tests = ( ("PATH_INFO", None), ("HTTP_ACCEPT", "Accept"), ("HTTP_USER_AGENT", "User-Agent"), ("HTTP_X_FORWARDED_PROTO", "X-Forwarded-Proto"), ("CONTENT_TYPE", "Content-Type"), ("CONTENT_LENGTH", "Content-Length"), ) for header, expected in tests: with self.subTest(header=header): self.assertEqual(HttpHeaders.parse_header_name(header), expected)
cd0f191dc94316ff3724e3948b7c656ab7ee4ba683e5ebd42d39f4d2df553111
from unittest import TestCase from django.http import HttpRequest from django.http.request import MediaType class MediaTypeTests(TestCase): def test_empty(self): for empty_media_type in (None, ""): with self.subTest(media_type=empty_media_type): media_type = MediaType(empty_media_type) self.assertIs(media_type.is_all_types, False) self.assertEqual(str(media_type), "") self.assertEqual(repr(media_type), "<MediaType: >") def test_str(self): self.assertEqual(str(MediaType("*/*; q=0.8")), "*/*; q=0.8") self.assertEqual(str(MediaType("application/xml")), "application/xml") def test_repr(self): self.assertEqual(repr(MediaType("*/*; q=0.8")), "<MediaType: */*; q=0.8>") self.assertEqual( repr(MediaType("application/xml")), "<MediaType: application/xml>", ) def test_is_all_types(self): self.assertIs(MediaType("*/*").is_all_types, True) self.assertIs(MediaType("*/*; q=0.8").is_all_types, True) self.assertIs(MediaType("text/*").is_all_types, False) self.assertIs(MediaType("application/xml").is_all_types, False) def test_match(self): tests = [ ("*/*; q=0.8", "*/*"), ("*/*", "application/json"), (" */* ", "application/json"), ("application/*", "application/json"), ("application/xml", "application/xml"), (" application/xml ", "application/xml"), ("application/xml", " application/xml "), ] for accepted_type, mime_type in tests: with self.subTest(accepted_type, mime_type=mime_type): self.assertIs(MediaType(accepted_type).match(mime_type), True) def test_no_match(self): tests = [ (None, "*/*"), ("", "*/*"), ("; q=0.8", "*/*"), ("application/xml", "application/html"), ("application/xml", "*/*"), ] for accepted_type, mime_type in tests: with self.subTest(accepted_type, mime_type=mime_type): self.assertIs(MediaType(accepted_type).match(mime_type), False) class AcceptHeaderTests(TestCase): def test_no_headers(self): """Absence of Accept header defaults to '*/*'.""" request = HttpRequest() self.assertEqual( [str(accepted_type) for accepted_type in request.accepted_types], ["*/*"], ) def test_accept_headers(self): request = HttpRequest() request.META[ "HTTP_ACCEPT" ] = "text/html, application/xhtml+xml,application/xml ;q=0.9,*/*;q=0.8" self.assertEqual( [str(accepted_type) for accepted_type in request.accepted_types], [ "text/html", "application/xhtml+xml", "application/xml; q=0.9", "*/*; q=0.8", ], ) def test_request_accepts_any(self): request = HttpRequest() request.META["HTTP_ACCEPT"] = "*/*" self.assertIs(request.accepts("application/json"), True) def test_request_accepts_none(self): request = HttpRequest() request.META["HTTP_ACCEPT"] = "" self.assertIs(request.accepts("application/json"), False) self.assertEqual(request.accepted_types, []) def test_request_accepts_some(self): request = HttpRequest() request.META[ "HTTP_ACCEPT" ] = "text/html,application/xhtml+xml,application/xml;q=0.9" self.assertIs(request.accepts("text/html"), True) self.assertIs(request.accepts("application/xhtml+xml"), True) self.assertIs(request.accepts("application/xml"), True) self.assertIs(request.accepts("application/json"), False)
2ac684e812eddc723f153d67670781d44a31723c76193c5dcdeb97ecd523d3d8
import datetime from unittest import mock from django.db import connections from django.db.models.sql.compiler import cursor_iter from django.test import TestCase from .models import Article class QuerySetIteratorTests(TestCase): itersize_index_in_mock_args = 3 @classmethod def setUpTestData(cls): Article.objects.create(name="Article 1", created=datetime.datetime.now()) Article.objects.create(name="Article 2", created=datetime.datetime.now()) def test_iterator_invalid_chunk_size(self): for size in (0, -1): with self.subTest(size=size): with self.assertRaisesMessage( ValueError, "Chunk size must be strictly positive." ): Article.objects.iterator(chunk_size=size) def test_default_iterator_chunk_size(self): qs = Article.objects.iterator() with mock.patch( "django.db.models.sql.compiler.cursor_iter", side_effect=cursor_iter ) as cursor_iter_mock: next(qs) self.assertEqual(cursor_iter_mock.call_count, 1) mock_args, _mock_kwargs = cursor_iter_mock.call_args self.assertEqual(mock_args[self.itersize_index_in_mock_args], 2000) def test_iterator_chunk_size(self): batch_size = 3 qs = Article.objects.iterator(chunk_size=batch_size) with mock.patch( "django.db.models.sql.compiler.cursor_iter", side_effect=cursor_iter ) as cursor_iter_mock: next(qs) self.assertEqual(cursor_iter_mock.call_count, 1) mock_args, _mock_kwargs = cursor_iter_mock.call_args self.assertEqual(mock_args[self.itersize_index_in_mock_args], batch_size) def test_no_chunked_reads(self): """ If the database backend doesn't support chunked reads, then the result of SQLCompiler.execute_sql() is a list. """ qs = Article.objects.all() compiler = qs.query.get_compiler(using=qs.db) features = connections[qs.db].features with mock.patch.object(features, "can_use_chunked_reads", False): result = compiler.execute_sql(chunked_fetch=True) self.assertIsInstance(result, list)
d58ce574dc797fc8e71fcc87930da499af81f7b96f2c827618eb3644c5b4f785
from django.db.models import BooleanField, Exists, F, OuterRef, Q from django.db.models.expressions import RawSQL from django.test import SimpleTestCase from .models import Tag class QTests(SimpleTestCase): def test_combine_and_empty(self): q = Q(x=1) self.assertEqual(q & Q(), q) self.assertEqual(Q() & q, q) q = Q(x__in={}.keys()) self.assertEqual(q & Q(), q) self.assertEqual(Q() & q, q) def test_combine_and_both_empty(self): self.assertEqual(Q() & Q(), Q()) def test_combine_or_empty(self): q = Q(x=1) self.assertEqual(q | Q(), q) self.assertEqual(Q() | q, q) q = Q(x__in={}.keys()) self.assertEqual(q | Q(), q) self.assertEqual(Q() | q, q) def test_combine_empty_copy(self): base_q = Q(x=1) tests = [ base_q | Q(), Q() | base_q, base_q & Q(), Q() & base_q, ] for i, q in enumerate(tests): with self.subTest(i=i): self.assertEqual(q, base_q) self.assertIsNot(q, base_q) def test_combine_or_both_empty(self): self.assertEqual(Q() | Q(), Q()) def test_combine_not_q_object(self): obj = object() q = Q(x=1) with self.assertRaisesMessage(TypeError, str(obj)): q | obj with self.assertRaisesMessage(TypeError, str(obj)): q & obj def test_combine_negated_boolean_expression(self): tagged = Tag.objects.filter(category=OuterRef("pk")) tests = [ Q() & ~Exists(tagged), Q() | ~Exists(tagged), ] for q in tests: with self.subTest(q=q): self.assertIs(q.negated, True) def test_deconstruct(self): q = Q(price__gt=F("discounted_price")) path, args, kwargs = q.deconstruct() self.assertEqual(path, "django.db.models.Q") self.assertEqual(args, (("price__gt", F("discounted_price")),)) self.assertEqual(kwargs, {}) def test_deconstruct_negated(self): q = ~Q(price__gt=F("discounted_price")) path, args, kwargs = q.deconstruct() self.assertEqual(args, (("price__gt", F("discounted_price")),)) self.assertEqual(kwargs, {"_negated": True}) def test_deconstruct_or(self): q1 = Q(price__gt=F("discounted_price")) q2 = Q(price=F("discounted_price")) q = q1 | q2 path, args, kwargs = q.deconstruct() self.assertEqual( args, ( ("price__gt", F("discounted_price")), ("price", F("discounted_price")), ), ) self.assertEqual(kwargs, {"_connector": "OR"}) def test_deconstruct_and(self): q1 = Q(price__gt=F("discounted_price")) q2 = Q(price=F("discounted_price")) q = q1 & q2 path, args, kwargs = q.deconstruct() self.assertEqual( args, ( ("price__gt", F("discounted_price")), ("price", F("discounted_price")), ), ) self.assertEqual(kwargs, {}) def test_deconstruct_multiple_kwargs(self): q = Q(price__gt=F("discounted_price"), price=F("discounted_price")) path, args, kwargs = q.deconstruct() self.assertEqual( args, ( ("price", F("discounted_price")), ("price__gt", F("discounted_price")), ), ) self.assertEqual(kwargs, {}) def test_deconstruct_nested(self): q = Q(Q(price__gt=F("discounted_price"))) path, args, kwargs = q.deconstruct() self.assertEqual(args, (Q(price__gt=F("discounted_price")),)) self.assertEqual(kwargs, {}) def test_deconstruct_boolean_expression(self): expr = RawSQL("1 = 1", BooleanField()) q = Q(expr) _, args, kwargs = q.deconstruct() self.assertEqual(args, (expr,)) self.assertEqual(kwargs, {}) def test_reconstruct(self): q = Q(price__gt=F("discounted_price")) path, args, kwargs = q.deconstruct() self.assertEqual(Q(*args, **kwargs), q) def test_reconstruct_negated(self): q = ~Q(price__gt=F("discounted_price")) path, args, kwargs = q.deconstruct() self.assertEqual(Q(*args, **kwargs), q) def test_reconstruct_or(self): q1 = Q(price__gt=F("discounted_price")) q2 = Q(price=F("discounted_price")) q = q1 | q2 path, args, kwargs = q.deconstruct() self.assertEqual(Q(*args, **kwargs), q) def test_reconstruct_and(self): q1 = Q(price__gt=F("discounted_price")) q2 = Q(price=F("discounted_price")) q = q1 & q2 path, args, kwargs = q.deconstruct() self.assertEqual(Q(*args, **kwargs), q)
29e346966d41115067a093ac039cb06b4f315ec4759ba8d2738052ad96970a00
import datetime import pickle import sys import unittest from operator import attrgetter from threading import Lock from django.core.exceptions import EmptyResultSet, FieldError from django.db import DEFAULT_DB_ALIAS, connection from django.db.models import Count, Exists, F, Max, OuterRef, Q from django.db.models.expressions import RawSQL from django.db.models.sql.constants import LOUTER from django.db.models.sql.where import NothingNode, WhereNode from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature from django.test.utils import CaptureQueriesContext, ignore_warnings from django.utils.deprecation import RemovedInDjango50Warning from .models import ( FK1, Annotation, Article, Author, BaseA, BaseUser, Book, CategoryItem, CategoryRelationship, Celebrity, Channel, Chapter, Child, ChildObjectA, Classroom, CommonMixedCaseForeignKeys, Company, Cover, CustomPk, CustomPkTag, DateTimePK, Detail, DumbCategory, Eaten, Employment, ExtraInfo, Fan, Food, Identifier, Individual, Item, Job, JobResponsibilities, Join, LeafA, LeafB, LoopX, LoopZ, ManagedModel, Member, MixedCaseDbColumnCategoryItem, MixedCaseFieldCategoryItem, ModelA, ModelB, ModelC, ModelD, MyObject, NamedCategory, Node, Note, NullableName, Number, ObjectA, ObjectB, ObjectC, OneToOneCategory, Order, OrderItem, Page, Paragraph, Person, Plaything, PointerA, Program, ProxyCategory, ProxyObjectA, ProxyObjectB, Ranking, Related, RelatedIndividual, RelatedObject, Report, ReportComment, ReservedName, Responsibility, School, SharedConnection, SimpleCategory, SingleObject, SpecialCategory, Staff, StaffUser, Student, Tag, Task, Teacher, Ticket21203Child, Ticket21203Parent, Ticket23605A, Ticket23605B, Ticket23605C, TvChef, Valid, X, ) class Queries1Tests(TestCase): @classmethod def setUpTestData(cls): cls.nc1 = generic = NamedCategory.objects.create(name="Generic") cls.t1 = Tag.objects.create(name="t1", category=generic) cls.t2 = Tag.objects.create(name="t2", parent=cls.t1, category=generic) cls.t3 = Tag.objects.create(name="t3", parent=cls.t1) cls.t4 = Tag.objects.create(name="t4", parent=cls.t3) cls.t5 = Tag.objects.create(name="t5", parent=cls.t3) cls.n1 = Note.objects.create(note="n1", misc="foo", id=1) cls.n2 = Note.objects.create(note="n2", misc="bar", id=2) cls.n3 = Note.objects.create(note="n3", misc="foo", id=3, negate=False) cls.ann1 = Annotation.objects.create(name="a1", tag=cls.t1) cls.ann1.notes.add(cls.n1) ann2 = Annotation.objects.create(name="a2", tag=cls.t4) ann2.notes.add(cls.n2, cls.n3) # Create these out of order so that sorting by 'id' will be different to sorting # by 'info'. Helps detect some problems later. cls.e2 = ExtraInfo.objects.create( info="e2", note=cls.n2, value=41, filterable=False ) e1 = ExtraInfo.objects.create(info="e1", note=cls.n1, value=42) cls.a1 = Author.objects.create(name="a1", num=1001, extra=e1) cls.a2 = Author.objects.create(name="a2", num=2002, extra=e1) cls.a3 = Author.objects.create(name="a3", num=3003, extra=cls.e2) cls.a4 = Author.objects.create(name="a4", num=4004, extra=cls.e2) cls.time1 = datetime.datetime(2007, 12, 19, 22, 25, 0) cls.time2 = datetime.datetime(2007, 12, 19, 21, 0, 0) time3 = datetime.datetime(2007, 12, 20, 22, 25, 0) time4 = datetime.datetime(2007, 12, 20, 21, 0, 0) cls.i1 = Item.objects.create( name="one", created=cls.time1, modified=cls.time1, creator=cls.a1, note=cls.n3, ) cls.i1.tags.set([cls.t1, cls.t2]) cls.i2 = Item.objects.create( name="two", created=cls.time2, creator=cls.a2, note=cls.n2 ) cls.i2.tags.set([cls.t1, cls.t3]) cls.i3 = Item.objects.create( name="three", created=time3, creator=cls.a2, note=cls.n3 ) cls.i4 = Item.objects.create( name="four", created=time4, creator=cls.a4, note=cls.n3 ) cls.i4.tags.set([cls.t4]) cls.r1 = Report.objects.create(name="r1", creator=cls.a1) cls.r2 = Report.objects.create(name="r2", creator=cls.a3) cls.r3 = Report.objects.create(name="r3") # Ordering by 'rank' gives us rank2, rank1, rank3. Ordering by the Meta.ordering # will be rank3, rank2, rank1. cls.rank1 = Ranking.objects.create(rank=2, author=cls.a2) cls.c1 = Cover.objects.create(title="first", item=cls.i4) cls.c2 = Cover.objects.create(title="second", item=cls.i2) def test_subquery_condition(self): qs1 = Tag.objects.filter(pk__lte=0) qs2 = Tag.objects.filter(parent__in=qs1) qs3 = Tag.objects.filter(parent__in=qs2) self.assertEqual(qs3.query.subq_aliases, {"T", "U", "V"}) self.assertIn("v0", str(qs3.query).lower()) qs4 = qs3.filter(parent__in=qs1) self.assertEqual(qs4.query.subq_aliases, {"T", "U", "V"}) # It is possible to reuse U for the second subquery, no need to use W. self.assertNotIn("w0", str(qs4.query).lower()) # So, 'U0."id"' is referenced in SELECT and WHERE twice. self.assertEqual(str(qs4.query).lower().count("u0."), 4) def test_ticket1050(self): self.assertSequenceEqual( Item.objects.filter(tags__isnull=True), [self.i3], ) self.assertSequenceEqual( Item.objects.filter(tags__id__isnull=True), [self.i3], ) def test_ticket1801(self): self.assertSequenceEqual( Author.objects.filter(item=self.i2), [self.a2], ) self.assertSequenceEqual( Author.objects.filter(item=self.i3), [self.a2], ) self.assertSequenceEqual( Author.objects.filter(item=self.i2) & Author.objects.filter(item=self.i3), [self.a2], ) def test_ticket2306(self): # Checking that no join types are "left outer" joins. query = Item.objects.filter(tags=self.t2).query self.assertNotIn(LOUTER, [x.join_type for x in query.alias_map.values()]) self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).order_by("name"), [self.i1, self.i2], ) self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).filter(Q(tags=self.t2)), [self.i1], ) self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1)).filter( Q(creator__name="fred") | Q(tags=self.t2) ), [self.i1], ) # Each filter call is processed "at once" against a single table, so this is # different from the previous example as it tries to find tags that are two # things at once (rather than two tags). self.assertSequenceEqual( Item.objects.filter(Q(tags=self.t1) & Q(tags=self.t2)), [] ) self.assertSequenceEqual( Item.objects.filter( Q(tags=self.t1), Q(creator__name="fred") | Q(tags=self.t2) ), [], ) qs = Author.objects.filter(ranking__rank=2, ranking__id=self.rank1.id) self.assertSequenceEqual(list(qs), [self.a2]) self.assertEqual(2, qs.query.count_active_tables(), 2) qs = Author.objects.filter(ranking__rank=2).filter(ranking__id=self.rank1.id) self.assertEqual(qs.query.count_active_tables(), 3) def test_ticket4464(self): self.assertSequenceEqual( Item.objects.filter(tags=self.t1).filter(tags=self.t2), [self.i1], ) self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]) .distinct() .order_by("name"), [self.i1, self.i2], ) self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).filter(tags=self.t3), [self.i2], ) # Make sure .distinct() works with slicing (this was broken in Oracle). self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]).order_by("name")[:3], [self.i1, self.i1, self.i2], ) self.assertSequenceEqual( Item.objects.filter(tags__in=[self.t1, self.t2]) .distinct() .order_by("name")[:3], [self.i1, self.i2], ) def test_tickets_2080_3592(self): self.assertSequenceEqual( Author.objects.filter(item__name="one") | Author.objects.filter(name="a3"), [self.a1, self.a3], ) self.assertSequenceEqual( Author.objects.filter(Q(item__name="one") | Q(name="a3")), [self.a1, self.a3], ) self.assertSequenceEqual( Author.objects.filter(Q(name="a3") | Q(item__name="one")), [self.a1, self.a3], ) self.assertSequenceEqual( Author.objects.filter(Q(item__name="three") | Q(report__name="r3")), [self.a2], ) def test_ticket6074(self): # Merging two empty result sets shouldn't leave a queryset with no constraints # (which would match everything). self.assertSequenceEqual(Author.objects.filter(Q(id__in=[])), []) self.assertSequenceEqual(Author.objects.filter(Q(id__in=[]) | Q(id__in=[])), []) def test_tickets_1878_2939(self): self.assertEqual(Item.objects.values("creator").distinct().count(), 3) # Create something with a duplicate 'name' so that we can test multi-column # cases (which require some tricky SQL transformations under the covers). xx = Item(name="four", created=self.time1, creator=self.a2, note=self.n1) xx.save() self.assertEqual( Item.objects.exclude(name="two") .values("creator", "name") .distinct() .count(), 4, ) self.assertEqual( ( Item.objects.exclude(name="two") .extra(select={"foo": "%s"}, select_params=(1,)) .values("creator", "name", "foo") .distinct() .count() ), 4, ) self.assertEqual( ( Item.objects.exclude(name="two") .extra(select={"foo": "%s"}, select_params=(1,)) .values("creator", "name") .distinct() .count() ), 4, ) xx.delete() def test_ticket7323(self): self.assertEqual(Item.objects.values("creator", "name").count(), 4) def test_ticket2253(self): q1 = Item.objects.order_by("name") q2 = Item.objects.filter(id=self.i1.id) self.assertSequenceEqual(q1, [self.i4, self.i1, self.i3, self.i2]) self.assertSequenceEqual(q2, [self.i1]) self.assertSequenceEqual( (q1 | q2).order_by("name"), [self.i4, self.i1, self.i3, self.i2], ) self.assertSequenceEqual((q1 & q2).order_by("name"), [self.i1]) q1 = Item.objects.filter(tags=self.t1) q2 = Item.objects.filter(note=self.n3, tags=self.t2) q3 = Item.objects.filter(creator=self.a4) self.assertSequenceEqual( ((q1 & q2) | q3).order_by("name"), [self.i4, self.i1], ) def test_order_by_tables(self): q1 = Item.objects.order_by("name") q2 = Item.objects.filter(id=self.i1.id) list(q2) combined_query = (q1 & q2).order_by("name").query self.assertEqual( len( [ t for t in combined_query.alias_map if combined_query.alias_refcount[t] ] ), 1, ) def test_order_by_join_unref(self): """ This test is related to the above one, testing that there aren't old JOINs in the query. """ qs = Celebrity.objects.order_by("greatest_fan__fan_of") self.assertIn("OUTER JOIN", str(qs.query)) qs = qs.order_by("id") self.assertNotIn("OUTER JOIN", str(qs.query)) def test_get_clears_ordering(self): """ get() should clear ordering for optimization purposes. """ with CaptureQueriesContext(connection) as captured_queries: Author.objects.order_by("name").get(pk=self.a1.pk) self.assertNotIn("order by", captured_queries[0]["sql"].lower()) def test_tickets_4088_4306(self): self.assertSequenceEqual(Report.objects.filter(creator=1001), [self.r1]) self.assertSequenceEqual(Report.objects.filter(creator__num=1001), [self.r1]) self.assertSequenceEqual(Report.objects.filter(creator__id=1001), []) self.assertSequenceEqual( Report.objects.filter(creator__id=self.a1.id), [self.r1] ) self.assertSequenceEqual(Report.objects.filter(creator__name="a1"), [self.r1]) def test_ticket4510(self): self.assertSequenceEqual( Author.objects.filter(report__name="r1"), [self.a1], ) def test_ticket7378(self): self.assertSequenceEqual(self.a1.report_set.all(), [self.r1]) def test_tickets_5324_6704(self): self.assertSequenceEqual( Item.objects.filter(tags__name="t4"), [self.i4], ) self.assertSequenceEqual( Item.objects.exclude(tags__name="t4").order_by("name").distinct(), [self.i1, self.i3, self.i2], ) self.assertSequenceEqual( Item.objects.exclude(tags__name="t4").order_by("name").distinct().reverse(), [self.i2, self.i3, self.i1], ) self.assertSequenceEqual( Author.objects.exclude(item__name="one").distinct().order_by("name"), [self.a2, self.a3, self.a4], ) # Excluding across a m2m relation when there is more than one related # object associated was problematic. self.assertSequenceEqual( Item.objects.exclude(tags__name="t1").order_by("name"), [self.i4, self.i3], ) self.assertSequenceEqual( Item.objects.exclude(tags__name="t1").exclude(tags__name="t4"), [self.i3], ) # Excluding from a relation that cannot be NULL should not use outer joins. query = Item.objects.exclude(creator__in=[self.a1, self.a2]).query self.assertNotIn(LOUTER, [x.join_type for x in query.alias_map.values()]) # Similarly, when one of the joins cannot possibly, ever, involve NULL # values (Author -> ExtraInfo, in the following), it should never be # promoted to a left outer join. So the following query should only # involve one "left outer" join (Author -> Item is 0-to-many). qs = Author.objects.filter(id=self.a1.id).filter( Q(extra__note=self.n1) | Q(item__note=self.n3) ) self.assertEqual( len( [ x for x in qs.query.alias_map.values() if x.join_type == LOUTER and qs.query.alias_refcount[x.table_alias] ] ), 1, ) # The previous changes shouldn't affect nullable foreign key joins. self.assertSequenceEqual( Tag.objects.filter(parent__isnull=True).order_by("name"), [self.t1] ) self.assertSequenceEqual( Tag.objects.exclude(parent__isnull=True).order_by("name"), [self.t2, self.t3, self.t4, self.t5], ) self.assertSequenceEqual( Tag.objects.exclude(Q(parent__name="t1") | Q(parent__isnull=True)).order_by( "name" ), [self.t4, self.t5], ) self.assertSequenceEqual( Tag.objects.exclude(Q(parent__isnull=True) | Q(parent__name="t1")).order_by( "name" ), [self.t4, self.t5], ) self.assertSequenceEqual( Tag.objects.exclude(Q(parent__parent__isnull=True)).order_by("name"), [self.t4, self.t5], ) self.assertSequenceEqual( Tag.objects.filter(~Q(parent__parent__isnull=True)).order_by("name"), [self.t4, self.t5], ) def test_ticket2091(self): t = Tag.objects.get(name="t4") self.assertSequenceEqual(Item.objects.filter(tags__in=[t]), [self.i4]) def test_avoid_infinite_loop_on_too_many_subqueries(self): x = Tag.objects.filter(pk=1) local_recursion_limit = sys.getrecursionlimit() // 16 msg = "Maximum recursion depth exceeded: too many subqueries." with self.assertRaisesMessage(RecursionError, msg): for i in range(local_recursion_limit + 2): x = Tag.objects.filter(pk__in=x) def test_reasonable_number_of_subq_aliases(self): x = Tag.objects.filter(pk=1) for _ in range(20): x = Tag.objects.filter(pk__in=x) self.assertEqual( x.query.subq_aliases, { "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", }, ) def test_heterogeneous_qs_combination(self): # Combining querysets built on different models should behave in a well-defined # fashion. We raise an error. msg = "Cannot combine queries on two different base models." with self.assertRaisesMessage(TypeError, msg): Author.objects.all() & Tag.objects.all() with self.assertRaisesMessage(TypeError, msg): Author.objects.all() | Tag.objects.all() def test_ticket3141(self): self.assertEqual(Author.objects.extra(select={"foo": "1"}).count(), 4) self.assertEqual( Author.objects.extra(select={"foo": "%s"}, select_params=(1,)).count(), 4 ) def test_ticket2400(self): self.assertSequenceEqual( Author.objects.filter(item__isnull=True), [self.a3], ) self.assertSequenceEqual( Tag.objects.filter(item__isnull=True), [self.t5], ) def test_ticket2496(self): self.assertSequenceEqual( Item.objects.extra(tables=["queries_author"]) .select_related() .order_by("name")[:1], [self.i4], ) def test_error_raised_on_filter_with_dictionary(self): with self.assertRaisesMessage(FieldError, "Cannot parse keyword query as dict"): Note.objects.filter({"note": "n1", "misc": "foo"}) def test_tickets_2076_7256(self): # Ordering on related tables should be possible, even if the table is # not otherwise involved. self.assertSequenceEqual( Item.objects.order_by("note__note", "name"), [self.i2, self.i4, self.i1, self.i3], ) # Ordering on a related field should use the remote model's default # ordering as a final step. self.assertSequenceEqual( Author.objects.order_by("extra", "-name"), [self.a2, self.a1, self.a4, self.a3], ) # Using remote model default ordering can span multiple models (in this # case, Cover is ordered by Item's default, which uses Note's default). self.assertSequenceEqual(Cover.objects.all(), [self.c1, self.c2]) # If the remote model does not have a default ordering, we order by its 'id' # field. self.assertSequenceEqual( Item.objects.order_by("creator", "name"), [self.i1, self.i3, self.i2, self.i4], ) # Ordering by a many-valued attribute (e.g. a many-to-many or reverse # ForeignKey) is legal, but the results might not make sense. That # isn't Django's problem. Garbage in, garbage out. self.assertSequenceEqual( Item.objects.filter(tags__isnull=False).order_by("tags", "id"), [self.i1, self.i2, self.i1, self.i2, self.i4], ) # If we replace the default ordering, Django adjusts the required # tables automatically. Item normally requires a join with Note to do # the default ordering, but that isn't needed here. qs = Item.objects.order_by("name") self.assertSequenceEqual(qs, [self.i4, self.i1, self.i3, self.i2]) self.assertEqual(len(qs.query.alias_map), 1) def test_tickets_2874_3002(self): qs = Item.objects.select_related().order_by("note__note", "name") self.assertQuerysetEqual(qs, [self.i2, self.i4, self.i1, self.i3]) # This is also a good select_related() test because there are multiple # Note entries in the SQL. The two Note items should be different. self.assertEqual(repr(qs[0].note), "<Note: n2>") self.assertEqual(repr(qs[0].creator.extra.note), "<Note: n1>") def test_ticket3037(self): self.assertSequenceEqual( Item.objects.filter( Q(creator__name="a3", name="two") | Q(creator__name="a4", name="four") ), [self.i4], ) def test_tickets_5321_7070(self): # Ordering columns must be included in the output columns. Note that # this means results that might otherwise be distinct are not (if there # are multiple values in the ordering cols), as in this example. This # isn't a bug; it's a warning to be careful with the selection of # ordering columns. self.assertSequenceEqual( Note.objects.values("misc").distinct().order_by("note", "-misc"), [{"misc": "foo"}, {"misc": "bar"}, {"misc": "foo"}], ) def test_ticket4358(self): # If you don't pass any fields to values(), relation fields are # returned as "foo_id" keys, not "foo". For consistency, you should be # able to pass "foo_id" in the fields list and have it work, too. We # actually allow both "foo" and "foo_id". # The *_id version is returned by default. self.assertIn("note_id", ExtraInfo.objects.values()[0]) # You can also pass it in explicitly. self.assertSequenceEqual( ExtraInfo.objects.values("note_id"), [{"note_id": 1}, {"note_id": 2}] ) # ...or use the field name. self.assertSequenceEqual( ExtraInfo.objects.values("note"), [{"note": 1}, {"note": 2}] ) def test_ticket6154(self): # Multiple filter statements are joined using "AND" all the time. self.assertSequenceEqual( Author.objects.filter(id=self.a1.id).filter( Q(extra__note=self.n1) | Q(item__note=self.n3) ), [self.a1], ) self.assertSequenceEqual( Author.objects.filter( Q(extra__note=self.n1) | Q(item__note=self.n3) ).filter(id=self.a1.id), [self.a1], ) def test_ticket6981(self): self.assertSequenceEqual( Tag.objects.select_related("parent").order_by("name"), [self.t1, self.t2, self.t3, self.t4, self.t5], ) def test_ticket9926(self): self.assertSequenceEqual( Tag.objects.select_related("parent", "category").order_by("name"), [self.t1, self.t2, self.t3, self.t4, self.t5], ) self.assertSequenceEqual( Tag.objects.select_related("parent", "parent__category").order_by("name"), [self.t1, self.t2, self.t3, self.t4, self.t5], ) def test_tickets_6180_6203(self): # Dates with limits and/or counts self.assertEqual(Item.objects.count(), 4) self.assertEqual(Item.objects.datetimes("created", "month").count(), 1) self.assertEqual(Item.objects.datetimes("created", "day").count(), 2) self.assertEqual(len(Item.objects.datetimes("created", "day")), 2) self.assertEqual( Item.objects.datetimes("created", "day")[0], datetime.datetime(2007, 12, 19, 0, 0), ) def test_tickets_7087_12242(self): # Dates with extra select columns self.assertSequenceEqual( Item.objects.datetimes("created", "day").extra(select={"a": 1}), [ datetime.datetime(2007, 12, 19, 0, 0), datetime.datetime(2007, 12, 20, 0, 0), ], ) self.assertSequenceEqual( Item.objects.extra(select={"a": 1}).datetimes("created", "day"), [ datetime.datetime(2007, 12, 19, 0, 0), datetime.datetime(2007, 12, 20, 0, 0), ], ) name = "one" self.assertSequenceEqual( Item.objects.datetimes("created", "day").extra( where=["name=%s"], params=[name] ), [datetime.datetime(2007, 12, 19, 0, 0)], ) self.assertSequenceEqual( Item.objects.extra(where=["name=%s"], params=[name]).datetimes( "created", "day" ), [datetime.datetime(2007, 12, 19, 0, 0)], ) def test_ticket7155(self): # Nullable dates self.assertSequenceEqual( Item.objects.datetimes("modified", "day"), [datetime.datetime(2007, 12, 19, 0, 0)], ) def test_order_by_rawsql(self): self.assertSequenceEqual( Item.objects.values("note__note").order_by( RawSQL("queries_note.note", ()), "id", ), [ {"note__note": "n2"}, {"note__note": "n3"}, {"note__note": "n3"}, {"note__note": "n3"}, ], ) def test_ticket7096(self): # Make sure exclude() with multiple conditions continues to work. self.assertSequenceEqual( Tag.objects.filter(parent=self.t1, name="t3").order_by("name"), [self.t3], ) self.assertSequenceEqual( Tag.objects.exclude(parent=self.t1, name="t3").order_by("name"), [self.t1, self.t2, self.t4, self.t5], ) self.assertSequenceEqual( Item.objects.exclude(tags__name="t1", name="one") .order_by("name") .distinct(), [self.i4, self.i3, self.i2], ) self.assertSequenceEqual( Item.objects.filter(name__in=["three", "four"]) .exclude(tags__name="t1") .order_by("name"), [self.i4, self.i3], ) # More twisted cases, involving nested negations. self.assertSequenceEqual( Item.objects.exclude(~Q(tags__name="t1", name="one")), [self.i1], ) self.assertSequenceEqual( Item.objects.filter(~Q(tags__name="t1", name="one"), name="two"), [self.i2], ) self.assertSequenceEqual( Item.objects.exclude(~Q(tags__name="t1", name="one"), name="two"), [self.i4, self.i1, self.i3], ) def test_tickets_7204_7506(self): # Make sure querysets with related fields can be pickled. If this # doesn't crash, it's a Good Thing. pickle.dumps(Item.objects.all()) def test_ticket7813(self): # We should also be able to pickle things that use select_related(). # The only tricky thing here is to ensure that we do the related # selections properly after unpickling. qs = Item.objects.select_related() query = qs.query.get_compiler(qs.db).as_sql()[0] query2 = pickle.loads(pickle.dumps(qs.query)) self.assertEqual(query2.get_compiler(qs.db).as_sql()[0], query) def test_deferred_load_qs_pickling(self): # Check pickling of deferred-loading querysets qs = Item.objects.defer("name", "creator") q2 = pickle.loads(pickle.dumps(qs)) self.assertEqual(list(qs), list(q2)) q3 = pickle.loads(pickle.dumps(qs, pickle.HIGHEST_PROTOCOL)) self.assertEqual(list(qs), list(q3)) def test_ticket7277(self): self.assertSequenceEqual( self.n1.annotation_set.filter( Q(tag=self.t5) | Q(tag__children=self.t5) | Q(tag__children__children=self.t5) ), [self.ann1], ) def test_tickets_7448_7707(self): # Complex objects should be converted to strings before being used in # lookups. self.assertSequenceEqual( Item.objects.filter(created__in=[self.time1, self.time2]), [self.i1, self.i2], ) def test_ticket7235(self): # An EmptyQuerySet should not raise exceptions if it is filtered. Eaten.objects.create(meal="m") q = Eaten.objects.none() with self.assertNumQueries(0): self.assertQuerysetEqual(q.all(), []) self.assertQuerysetEqual(q.filter(meal="m"), []) self.assertQuerysetEqual(q.exclude(meal="m"), []) self.assertQuerysetEqual(q.complex_filter({"pk": 1}), []) self.assertQuerysetEqual(q.select_related("food"), []) self.assertQuerysetEqual(q.annotate(Count("food")), []) self.assertQuerysetEqual(q.order_by("meal", "food"), []) self.assertQuerysetEqual(q.distinct(), []) self.assertQuerysetEqual(q.extra(select={"foo": "1"}), []) self.assertQuerysetEqual(q.reverse(), []) q.query.low_mark = 1 msg = "Cannot change a query once a slice has been taken." with self.assertRaisesMessage(TypeError, msg): q.extra(select={"foo": "1"}) self.assertQuerysetEqual(q.defer("meal"), []) self.assertQuerysetEqual(q.only("meal"), []) def test_ticket7791(self): # There were "issues" when ordering and distinct-ing on fields related # via ForeignKeys. self.assertEqual(len(Note.objects.order_by("extrainfo__info").distinct()), 3) # Pickling of QuerySets using datetimes() should work. qs = Item.objects.datetimes("created", "month") pickle.loads(pickle.dumps(qs)) def test_ticket9997(self): # If a ValuesList or Values queryset is passed as an inner query, we # make sure it's only requesting a single value and use that as the # thing to select. self.assertSequenceEqual( Tag.objects.filter( name__in=Tag.objects.filter(parent=self.t1).values("name") ), [self.t2, self.t3], ) # Multi-valued values() and values_list() querysets should raise errors. with self.assertRaisesMessage( TypeError, "Cannot use multi-field values as a filter value." ): Tag.objects.filter( name__in=Tag.objects.filter(parent=self.t1).values("name", "id") ) with self.assertRaisesMessage( TypeError, "Cannot use multi-field values as a filter value." ): Tag.objects.filter( name__in=Tag.objects.filter(parent=self.t1).values_list("name", "id") ) def test_ticket9985(self): # qs.values_list(...).values(...) combinations should work. self.assertSequenceEqual( Note.objects.values_list("note", flat=True).values("id").order_by("id"), [{"id": 1}, {"id": 2}, {"id": 3}], ) self.assertSequenceEqual( Annotation.objects.filter( notes__in=Note.objects.filter(note="n1") .values_list("note") .values("id") ), [self.ann1], ) def test_ticket10205(self): # When bailing out early because of an empty "__in" filter, we need # to set things up correctly internally so that subqueries can continue # properly. self.assertEqual(Tag.objects.filter(name__in=()).update(name="foo"), 0) def test_ticket10432(self): # Testing an empty "__in" filter with a generator as the value. def f(): return iter([]) n_obj = Note.objects.all()[0] def g(): yield n_obj.pk self.assertQuerysetEqual(Note.objects.filter(pk__in=f()), []) self.assertEqual(list(Note.objects.filter(pk__in=g())), [n_obj]) def test_ticket10742(self): # Queries used in an __in clause don't execute subqueries subq = Author.objects.filter(num__lt=3000) qs = Author.objects.filter(pk__in=subq) self.assertSequenceEqual(qs, [self.a1, self.a2]) # The subquery result cache should not be populated self.assertIsNone(subq._result_cache) subq = Author.objects.filter(num__lt=3000) qs = Author.objects.exclude(pk__in=subq) self.assertSequenceEqual(qs, [self.a3, self.a4]) # The subquery result cache should not be populated self.assertIsNone(subq._result_cache) subq = Author.objects.filter(num__lt=3000) self.assertSequenceEqual( Author.objects.filter(Q(pk__in=subq) & Q(name="a1")), [self.a1], ) # The subquery result cache should not be populated self.assertIsNone(subq._result_cache) def test_ticket7076(self): # Excluding shouldn't eliminate NULL entries. self.assertSequenceEqual( Item.objects.exclude(modified=self.time1).order_by("name"), [self.i4, self.i3, self.i2], ) self.assertSequenceEqual( Tag.objects.exclude(parent__name=self.t1.name), [self.t1, self.t4, self.t5], ) def test_ticket7181(self): # Ordering by related tables should accommodate nullable fields (this # test is a little tricky, since NULL ordering is database dependent. # Instead, we just count the number of results). self.assertEqual(len(Tag.objects.order_by("parent__name")), 5) # Empty querysets can be merged with others. self.assertSequenceEqual( Note.objects.none() | Note.objects.all(), [self.n1, self.n2, self.n3], ) self.assertSequenceEqual( Note.objects.all() | Note.objects.none(), [self.n1, self.n2, self.n3], ) self.assertSequenceEqual(Note.objects.none() & Note.objects.all(), []) self.assertSequenceEqual(Note.objects.all() & Note.objects.none(), []) def test_ticket8439(self): # Complex combinations of conjunctions, disjunctions and nullable # relations. self.assertSequenceEqual( Author.objects.filter( Q(item__note__extrainfo=self.e2) | Q(report=self.r1, name="xyz") ), [self.a2], ) self.assertSequenceEqual( Author.objects.filter( Q(report=self.r1, name="xyz") | Q(item__note__extrainfo=self.e2) ), [self.a2], ) self.assertSequenceEqual( Annotation.objects.filter( Q(tag__parent=self.t1) | Q(notes__note="n1", name="a1") ), [self.ann1], ) xx = ExtraInfo.objects.create(info="xx", note=self.n3) self.assertSequenceEqual( Note.objects.filter(Q(extrainfo__author=self.a1) | Q(extrainfo=xx)), [self.n1, self.n3], ) q = Note.objects.filter(Q(extrainfo__author=self.a1) | Q(extrainfo=xx)).query self.assertEqual( len( [ x for x in q.alias_map.values() if x.join_type == LOUTER and q.alias_refcount[x.table_alias] ] ), 1, ) def test_ticket17429(self): """ Meta.ordering=None works the same as Meta.ordering=[] """ original_ordering = Tag._meta.ordering Tag._meta.ordering = None try: self.assertCountEqual( Tag.objects.all(), [self.t1, self.t2, self.t3, self.t4, self.t5], ) finally: Tag._meta.ordering = original_ordering def test_exclude(self): self.assertQuerysetEqual( Item.objects.exclude(tags__name="t4"), Item.objects.filter(~Q(tags__name="t4")), ) self.assertQuerysetEqual( Item.objects.exclude(Q(tags__name="t4") | Q(tags__name="t3")), Item.objects.filter(~(Q(tags__name="t4") | Q(tags__name="t3"))), ) self.assertQuerysetEqual( Item.objects.exclude(Q(tags__name="t4") | ~Q(tags__name="t3")), Item.objects.filter(~(Q(tags__name="t4") | ~Q(tags__name="t3"))), ) def test_nested_exclude(self): self.assertQuerysetEqual( Item.objects.exclude(~Q(tags__name="t4")), Item.objects.filter(~~Q(tags__name="t4")), ) def test_double_exclude(self): self.assertQuerysetEqual( Item.objects.filter(Q(tags__name="t4")), Item.objects.filter(~~Q(tags__name="t4")), ) self.assertQuerysetEqual( Item.objects.filter(Q(tags__name="t4")), Item.objects.filter(~Q(~Q(tags__name="t4"))), ) def test_exclude_in(self): self.assertQuerysetEqual( Item.objects.exclude(Q(tags__name__in=["t4", "t3"])), Item.objects.filter(~Q(tags__name__in=["t4", "t3"])), ) self.assertQuerysetEqual( Item.objects.filter(Q(tags__name__in=["t4", "t3"])), Item.objects.filter(~~Q(tags__name__in=["t4", "t3"])), ) def test_ticket_10790_1(self): # Querying direct fields with isnull should trim the left outer join. # It also should not create INNER JOIN. q = Tag.objects.filter(parent__isnull=True) self.assertSequenceEqual(q, [self.t1]) self.assertNotIn("JOIN", str(q.query)) q = Tag.objects.filter(parent__isnull=False) self.assertSequenceEqual(q, [self.t2, self.t3, self.t4, self.t5]) self.assertNotIn("JOIN", str(q.query)) q = Tag.objects.exclude(parent__isnull=True) self.assertSequenceEqual(q, [self.t2, self.t3, self.t4, self.t5]) self.assertNotIn("JOIN", str(q.query)) q = Tag.objects.exclude(parent__isnull=False) self.assertSequenceEqual(q, [self.t1]) self.assertNotIn("JOIN", str(q.query)) q = Tag.objects.exclude(parent__parent__isnull=False) self.assertSequenceEqual(q, [self.t1, self.t2, self.t3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 1) self.assertNotIn("INNER JOIN", str(q.query)) def test_ticket_10790_2(self): # Querying across several tables should strip only the last outer join, # while preserving the preceding inner joins. q = Tag.objects.filter(parent__parent__isnull=False) self.assertSequenceEqual(q, [self.t4, self.t5]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 1) # Querying without isnull should not convert anything to left outer join. q = Tag.objects.filter(parent__parent=self.t1) self.assertSequenceEqual(q, [self.t4, self.t5]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 1) def test_ticket_10790_3(self): # Querying via indirect fields should populate the left outer join q = NamedCategory.objects.filter(tag__isnull=True) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 1) # join to dumbcategory ptr_id self.assertEqual(str(q.query).count("INNER JOIN"), 1) self.assertSequenceEqual(q, []) # Querying across several tables should strip only the last join, while # preserving the preceding left outer joins. q = NamedCategory.objects.filter(tag__parent__isnull=True) self.assertEqual(str(q.query).count("INNER JOIN"), 1) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 1) self.assertSequenceEqual(q, [self.nc1]) def test_ticket_10790_4(self): # Querying across m2m field should not strip the m2m table from join. q = Author.objects.filter(item__tags__isnull=True) self.assertSequenceEqual(q, [self.a2, self.a3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 2) self.assertNotIn("INNER JOIN", str(q.query)) q = Author.objects.filter(item__tags__parent__isnull=True) self.assertSequenceEqual(q, [self.a1, self.a2, self.a2, self.a3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 3) self.assertNotIn("INNER JOIN", str(q.query)) def test_ticket_10790_5(self): # Querying with isnull=False across m2m field should not create outer joins q = Author.objects.filter(item__tags__isnull=False) self.assertSequenceEqual(q, [self.a1, self.a1, self.a2, self.a2, self.a4]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 2) q = Author.objects.filter(item__tags__parent__isnull=False) self.assertSequenceEqual(q, [self.a1, self.a2, self.a4]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 3) q = Author.objects.filter(item__tags__parent__parent__isnull=False) self.assertSequenceEqual(q, [self.a4]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 4) def test_ticket_10790_6(self): # Querying with isnull=True across m2m field should not create inner joins # and strip last outer join q = Author.objects.filter(item__tags__parent__parent__isnull=True) self.assertSequenceEqual( q, [self.a1, self.a1, self.a2, self.a2, self.a2, self.a3], ) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 4) self.assertEqual(str(q.query).count("INNER JOIN"), 0) q = Author.objects.filter(item__tags__parent__isnull=True) self.assertSequenceEqual(q, [self.a1, self.a2, self.a2, self.a3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 3) self.assertEqual(str(q.query).count("INNER JOIN"), 0) def test_ticket_10790_7(self): # Reverse querying with isnull should not strip the join q = Author.objects.filter(item__isnull=True) self.assertSequenceEqual(q, [self.a3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 1) self.assertEqual(str(q.query).count("INNER JOIN"), 0) q = Author.objects.filter(item__isnull=False) self.assertSequenceEqual(q, [self.a1, self.a2, self.a2, self.a4]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 1) def test_ticket_10790_8(self): # Querying with combined q-objects should also strip the left outer join q = Tag.objects.filter(Q(parent__isnull=True) | Q(parent=self.t1)) self.assertSequenceEqual(q, [self.t1, self.t2, self.t3]) self.assertEqual(str(q.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q.query).count("INNER JOIN"), 0) def test_ticket_10790_combine(self): # Combining queries should not re-populate the left outer join q1 = Tag.objects.filter(parent__isnull=True) q2 = Tag.objects.filter(parent__isnull=False) q3 = q1 | q2 self.assertSequenceEqual(q3, [self.t1, self.t2, self.t3, self.t4, self.t5]) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) q3 = q1 & q2 self.assertSequenceEqual(q3, []) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) q2 = Tag.objects.filter(parent=self.t1) q3 = q1 | q2 self.assertSequenceEqual(q3, [self.t1, self.t2, self.t3]) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) q3 = q2 | q1 self.assertSequenceEqual(q3, [self.t1, self.t2, self.t3]) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) q1 = Tag.objects.filter(parent__isnull=True) q2 = Tag.objects.filter(parent__parent__isnull=True) q3 = q1 | q2 self.assertSequenceEqual(q3, [self.t1, self.t2, self.t3]) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 1) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) q3 = q2 | q1 self.assertSequenceEqual(q3, [self.t1, self.t2, self.t3]) self.assertEqual(str(q3.query).count("LEFT OUTER JOIN"), 1) self.assertEqual(str(q3.query).count("INNER JOIN"), 0) def test_ticket19672(self): self.assertSequenceEqual( Report.objects.filter( Q(creator__isnull=False) & ~Q(creator__extra__value=41) ), [self.r1], ) def test_ticket_20250(self): # A negated Q along with an annotated queryset failed in Django 1.4 qs = Author.objects.annotate(Count("item")) qs = qs.filter(~Q(extra__value=0)).order_by("name") self.assertIn("SELECT", str(qs.query)) self.assertSequenceEqual(qs, [self.a1, self.a2, self.a3, self.a4]) def test_lookup_constraint_fielderror(self): msg = ( "Cannot resolve keyword 'unknown_field' into field. Choices are: " "annotation, category, category_id, children, id, item, " "managedmodel, name, note, parent, parent_id" ) with self.assertRaisesMessage(FieldError, msg): Tag.objects.filter(unknown_field__name="generic") def test_common_mixed_case_foreign_keys(self): """ Valid query should be generated when fields fetched from joined tables include FKs whose names only differ by case. """ c1 = SimpleCategory.objects.create(name="c1") c2 = SimpleCategory.objects.create(name="c2") c3 = SimpleCategory.objects.create(name="c3") category = CategoryItem.objects.create(category=c1) mixed_case_field_category = MixedCaseFieldCategoryItem.objects.create( CaTeGoRy=c2 ) mixed_case_db_column_category = MixedCaseDbColumnCategoryItem.objects.create( category=c3 ) CommonMixedCaseForeignKeys.objects.create( category=category, mixed_case_field_category=mixed_case_field_category, mixed_case_db_column_category=mixed_case_db_column_category, ) qs = CommonMixedCaseForeignKeys.objects.values( "category", "mixed_case_field_category", "mixed_case_db_column_category", "category__category", "mixed_case_field_category__CaTeGoRy", "mixed_case_db_column_category__category", ) self.assertTrue(qs.first()) def test_excluded_intermediary_m2m_table_joined(self): self.assertSequenceEqual( Note.objects.filter(~Q(tag__annotation__name=F("note"))), [self.n1, self.n2, self.n3], ) self.assertSequenceEqual( Note.objects.filter(tag__annotation__name="a1").filter( ~Q(tag__annotation__name=F("note")) ), [], ) def test_field_with_filterable(self): self.assertSequenceEqual( Author.objects.filter(extra=self.e2), [self.a3, self.a4], ) def test_negate_field(self): self.assertSequenceEqual( Note.objects.filter(negate=True), [self.n1, self.n2], ) self.assertSequenceEqual(Note.objects.exclude(negate=True), [self.n3]) class Queries2Tests(TestCase): @classmethod def setUpTestData(cls): cls.num4 = Number.objects.create(num=4) cls.num8 = Number.objects.create(num=8) cls.num12 = Number.objects.create(num=12) def test_ticket4289(self): # A slight variation on the restricting the filtering choices by the # lookup constraints. self.assertSequenceEqual(Number.objects.filter(num__lt=4), []) self.assertSequenceEqual(Number.objects.filter(num__gt=8, num__lt=12), []) self.assertSequenceEqual( Number.objects.filter(num__gt=8, num__lt=13), [self.num12], ) self.assertSequenceEqual( Number.objects.filter(Q(num__lt=4) | Q(num__gt=8, num__lt=12)), [] ) self.assertSequenceEqual( Number.objects.filter(Q(num__gt=8, num__lt=12) | Q(num__lt=4)), [] ) self.assertSequenceEqual( Number.objects.filter(Q(num__gt=8) & Q(num__lt=12) | Q(num__lt=4)), [] ) self.assertSequenceEqual( Number.objects.filter(Q(num__gt=7) & Q(num__lt=12) | Q(num__lt=4)), [self.num8], ) def test_ticket12239(self): # Custom lookups are registered to round float values correctly on gte # and lt IntegerField queries. self.assertSequenceEqual( Number.objects.filter(num__gt=11.9), [self.num12], ) self.assertSequenceEqual(Number.objects.filter(num__gt=12), []) self.assertSequenceEqual(Number.objects.filter(num__gt=12.0), []) self.assertSequenceEqual(Number.objects.filter(num__gt=12.1), []) self.assertCountEqual( Number.objects.filter(num__lt=12), [self.num4, self.num8], ) self.assertCountEqual( Number.objects.filter(num__lt=12.0), [self.num4, self.num8], ) self.assertCountEqual( Number.objects.filter(num__lt=12.1), [self.num4, self.num8, self.num12], ) self.assertCountEqual( Number.objects.filter(num__gte=11.9), [self.num12], ) self.assertCountEqual( Number.objects.filter(num__gte=12), [self.num12], ) self.assertCountEqual( Number.objects.filter(num__gte=12.0), [self.num12], ) self.assertSequenceEqual(Number.objects.filter(num__gte=12.1), []) self.assertSequenceEqual(Number.objects.filter(num__gte=12.9), []) self.assertCountEqual( Number.objects.filter(num__lte=11.9), [self.num4, self.num8], ) self.assertCountEqual( Number.objects.filter(num__lte=12), [self.num4, self.num8, self.num12], ) self.assertCountEqual( Number.objects.filter(num__lte=12.0), [self.num4, self.num8, self.num12], ) self.assertCountEqual( Number.objects.filter(num__lte=12.1), [self.num4, self.num8, self.num12], ) self.assertCountEqual( Number.objects.filter(num__lte=12.9), [self.num4, self.num8, self.num12], ) def test_ticket7759(self): # Count should work with a partially read result set. count = Number.objects.count() qs = Number.objects.all() def run(): for obj in qs: return qs.count() == count self.assertTrue(run()) class Queries3Tests(TestCase): def test_ticket7107(self): # This shouldn't create an infinite loop. self.assertQuerysetEqual(Valid.objects.all(), []) def test_datetimes_invalid_field(self): # An error should be raised when QuerySet.datetimes() is passed the # wrong type of field. msg = "'name' isn't a DateField, TimeField, or DateTimeField." with self.assertRaisesMessage(TypeError, msg): Item.objects.datetimes("name", "month") def test_ticket22023(self): with self.assertRaisesMessage( TypeError, "Cannot call only() after .values() or .values_list()" ): Valid.objects.values().only() with self.assertRaisesMessage( TypeError, "Cannot call defer() after .values() or .values_list()" ): Valid.objects.values().defer() class Queries4Tests(TestCase): @classmethod def setUpTestData(cls): generic = NamedCategory.objects.create(name="Generic") cls.t1 = Tag.objects.create(name="t1", category=generic) n1 = Note.objects.create(note="n1", misc="foo") n2 = Note.objects.create(note="n2", misc="bar") e1 = ExtraInfo.objects.create(info="e1", note=n1) e2 = ExtraInfo.objects.create(info="e2", note=n2) cls.a1 = Author.objects.create(name="a1", num=1001, extra=e1) cls.a3 = Author.objects.create(name="a3", num=3003, extra=e2) cls.r1 = Report.objects.create(name="r1", creator=cls.a1) cls.r2 = Report.objects.create(name="r2", creator=cls.a3) cls.r3 = Report.objects.create(name="r3") cls.i1 = Item.objects.create( name="i1", created=datetime.datetime.now(), note=n1, creator=cls.a1 ) cls.i2 = Item.objects.create( name="i2", created=datetime.datetime.now(), note=n1, creator=cls.a3 ) def test_ticket24525(self): tag = Tag.objects.create() anth100 = tag.note_set.create(note="ANTH", misc="100") math101 = tag.note_set.create(note="MATH", misc="101") s1 = tag.annotation_set.create(name="1") s2 = tag.annotation_set.create(name="2") s1.notes.set([math101, anth100]) s2.notes.set([math101]) result = math101.annotation_set.all() & tag.annotation_set.exclude( notes__in=[anth100] ) self.assertEqual(list(result), [s2]) def test_ticket11811(self): unsaved_category = NamedCategory(name="Other") msg = ( "Unsaved model instance <NamedCategory: Other> cannot be used in an ORM " "query." ) with self.assertRaisesMessage(ValueError, msg): Tag.objects.filter(pk=self.t1.pk).update(category=unsaved_category) def test_ticket14876(self): # Note: when combining the query we need to have information available # about the join type of the trimmed "creator__isnull" join. If we # don't have that information, then the join is created as INNER JOIN # and results will be incorrect. q1 = Report.objects.filter( Q(creator__isnull=True) | Q(creator__extra__info="e1") ) q2 = Report.objects.filter(Q(creator__isnull=True)) | Report.objects.filter( Q(creator__extra__info="e1") ) self.assertCountEqual(q1, [self.r1, self.r3]) self.assertEqual(str(q1.query), str(q2.query)) q1 = Report.objects.filter( Q(creator__extra__info="e1") | Q(creator__isnull=True) ) q2 = Report.objects.filter( Q(creator__extra__info="e1") ) | Report.objects.filter(Q(creator__isnull=True)) self.assertCountEqual(q1, [self.r1, self.r3]) self.assertEqual(str(q1.query), str(q2.query)) q1 = Item.objects.filter( Q(creator=self.a1) | Q(creator__report__name="r1") ).order_by() q2 = ( Item.objects.filter(Q(creator=self.a1)).order_by() | Item.objects.filter(Q(creator__report__name="r1")).order_by() ) self.assertCountEqual(q1, [self.i1]) self.assertEqual(str(q1.query), str(q2.query)) q1 = Item.objects.filter( Q(creator__report__name="e1") | Q(creator=self.a1) ).order_by() q2 = ( Item.objects.filter(Q(creator__report__name="e1")).order_by() | Item.objects.filter(Q(creator=self.a1)).order_by() ) self.assertCountEqual(q1, [self.i1]) self.assertEqual(str(q1.query), str(q2.query)) def test_combine_join_reuse(self): # Joins having identical connections are correctly recreated in the # rhs query, in case the query is ORed together (#18748). Report.objects.create(name="r4", creator=self.a1) q1 = Author.objects.filter(report__name="r5") q2 = Author.objects.filter(report__name="r4").filter(report__name="r1") combined = q1 | q2 self.assertEqual(str(combined.query).count("JOIN"), 2) self.assertEqual(len(combined), 1) self.assertEqual(combined[0].name, "a1") def test_combine_or_filter_reuse(self): combined = Author.objects.filter(name="a1") | Author.objects.filter(name="a3") self.assertEqual(combined.get(name="a1"), self.a1) def test_join_reuse_order(self): # Join aliases are reused in order. This shouldn't raise AssertionError # because change_map contains a circular reference (#26522). s1 = School.objects.create() s2 = School.objects.create() s3 = School.objects.create() t1 = Teacher.objects.create() otherteachers = Teacher.objects.exclude(pk=t1.pk).exclude(friends=t1) qs1 = otherteachers.filter(schools=s1).filter(schools=s2) qs2 = otherteachers.filter(schools=s1).filter(schools=s3) self.assertQuerysetEqual(qs1 | qs2, []) def test_ticket7095(self): # Updates that are filtered on the model being updated are somewhat # tricky in MySQL. ManagedModel.objects.create(data="mm1", tag=self.t1, public=True) self.assertEqual(ManagedModel.objects.update(data="mm"), 1) # A values() or values_list() query across joined models must use outer # joins appropriately. # Note: In Oracle, we expect a null CharField to return '' instead of # None. if connection.features.interprets_empty_strings_as_nulls: expected_null_charfield_repr = "" else: expected_null_charfield_repr = None self.assertSequenceEqual( Report.objects.values_list("creator__extra__info", flat=True).order_by( "name" ), ["e1", "e2", expected_null_charfield_repr], ) # Similarly for select_related(), joins beyond an initial nullable join # must use outer joins so that all results are included. self.assertSequenceEqual( Report.objects.select_related("creator", "creator__extra").order_by("name"), [self.r1, self.r2, self.r3], ) # When there are multiple paths to a table from another table, we have # to be careful not to accidentally reuse an inappropriate join when # using select_related(). We used to return the parent's Detail record # here by mistake. d1 = Detail.objects.create(data="d1") d2 = Detail.objects.create(data="d2") m1 = Member.objects.create(name="m1", details=d1) m2 = Member.objects.create(name="m2", details=d2) Child.objects.create(person=m2, parent=m1) obj = m1.children.select_related("person__details")[0] self.assertEqual(obj.person.details.data, "d2") def test_order_by_resetting(self): # Calling order_by() with no parameters removes any existing ordering on the # model. But it should still be possible to add new ordering after that. qs = Author.objects.order_by().order_by("name") self.assertIn("ORDER BY", qs.query.get_compiler(qs.db).as_sql()[0]) def test_order_by_reverse_fk(self): # It is possible to order by reverse of foreign key, although that can lead # to duplicate results. c1 = SimpleCategory.objects.create(name="category1") c2 = SimpleCategory.objects.create(name="category2") CategoryItem.objects.create(category=c1) CategoryItem.objects.create(category=c2) CategoryItem.objects.create(category=c1) self.assertSequenceEqual( SimpleCategory.objects.order_by("categoryitem", "pk"), [c1, c2, c1] ) def test_filter_reverse_non_integer_pk(self): date_obj = DateTimePK.objects.create() extra_obj = ExtraInfo.objects.create(info="extra", date=date_obj) self.assertEqual( DateTimePK.objects.filter(extrainfo=extra_obj).get(), date_obj, ) def test_ticket10181(self): # Avoid raising an EmptyResultSet if an inner query is probably # empty (and hence, not executed). self.assertQuerysetEqual( Tag.objects.filter(id__in=Tag.objects.filter(id__in=[])), [] ) def test_ticket15316_filter_false(self): c1 = SimpleCategory.objects.create(name="category1") c2 = SpecialCategory.objects.create( name="named category1", special_name="special1" ) c3 = SpecialCategory.objects.create( name="named category2", special_name="special2" ) CategoryItem.objects.create(category=c1) ci2 = CategoryItem.objects.create(category=c2) ci3 = CategoryItem.objects.create(category=c3) qs = CategoryItem.objects.filter(category__specialcategory__isnull=False) self.assertEqual(qs.count(), 2) self.assertSequenceEqual(qs, [ci2, ci3]) def test_ticket15316_exclude_false(self): c1 = SimpleCategory.objects.create(name="category1") c2 = SpecialCategory.objects.create( name="named category1", special_name="special1" ) c3 = SpecialCategory.objects.create( name="named category2", special_name="special2" ) ci1 = CategoryItem.objects.create(category=c1) CategoryItem.objects.create(category=c2) CategoryItem.objects.create(category=c3) qs = CategoryItem.objects.exclude(category__specialcategory__isnull=False) self.assertEqual(qs.count(), 1) self.assertSequenceEqual(qs, [ci1]) def test_ticket15316_filter_true(self): c1 = SimpleCategory.objects.create(name="category1") c2 = SpecialCategory.objects.create( name="named category1", special_name="special1" ) c3 = SpecialCategory.objects.create( name="named category2", special_name="special2" ) ci1 = CategoryItem.objects.create(category=c1) CategoryItem.objects.create(category=c2) CategoryItem.objects.create(category=c3) qs = CategoryItem.objects.filter(category__specialcategory__isnull=True) self.assertEqual(qs.count(), 1) self.assertSequenceEqual(qs, [ci1]) def test_ticket15316_exclude_true(self): c1 = SimpleCategory.objects.create(name="category1") c2 = SpecialCategory.objects.create( name="named category1", special_name="special1" ) c3 = SpecialCategory.objects.create( name="named category2", special_name="special2" ) CategoryItem.objects.create(category=c1) ci2 = CategoryItem.objects.create(category=c2) ci3 = CategoryItem.objects.create(category=c3) qs = CategoryItem.objects.exclude(category__specialcategory__isnull=True) self.assertEqual(qs.count(), 2) self.assertSequenceEqual(qs, [ci2, ci3]) def test_ticket15316_one2one_filter_false(self): c = SimpleCategory.objects.create(name="cat") c0 = SimpleCategory.objects.create(name="cat0") c1 = SimpleCategory.objects.create(name="category1") OneToOneCategory.objects.create(category=c1, new_name="new1") OneToOneCategory.objects.create(category=c0, new_name="new2") CategoryItem.objects.create(category=c) ci2 = CategoryItem.objects.create(category=c0) ci3 = CategoryItem.objects.create(category=c1) qs = CategoryItem.objects.filter( category__onetoonecategory__isnull=False ).order_by("pk") self.assertEqual(qs.count(), 2) self.assertSequenceEqual(qs, [ci2, ci3]) def test_ticket15316_one2one_exclude_false(self): c = SimpleCategory.objects.create(name="cat") c0 = SimpleCategory.objects.create(name="cat0") c1 = SimpleCategory.objects.create(name="category1") OneToOneCategory.objects.create(category=c1, new_name="new1") OneToOneCategory.objects.create(category=c0, new_name="new2") ci1 = CategoryItem.objects.create(category=c) CategoryItem.objects.create(category=c0) CategoryItem.objects.create(category=c1) qs = CategoryItem.objects.exclude(category__onetoonecategory__isnull=False) self.assertEqual(qs.count(), 1) self.assertSequenceEqual(qs, [ci1]) def test_ticket15316_one2one_filter_true(self): c = SimpleCategory.objects.create(name="cat") c0 = SimpleCategory.objects.create(name="cat0") c1 = SimpleCategory.objects.create(name="category1") OneToOneCategory.objects.create(category=c1, new_name="new1") OneToOneCategory.objects.create(category=c0, new_name="new2") ci1 = CategoryItem.objects.create(category=c) CategoryItem.objects.create(category=c0) CategoryItem.objects.create(category=c1) qs = CategoryItem.objects.filter(category__onetoonecategory__isnull=True) self.assertEqual(qs.count(), 1) self.assertSequenceEqual(qs, [ci1]) def test_ticket15316_one2one_exclude_true(self): c = SimpleCategory.objects.create(name="cat") c0 = SimpleCategory.objects.create(name="cat0") c1 = SimpleCategory.objects.create(name="category1") OneToOneCategory.objects.create(category=c1, new_name="new1") OneToOneCategory.objects.create(category=c0, new_name="new2") CategoryItem.objects.create(category=c) ci2 = CategoryItem.objects.create(category=c0) ci3 = CategoryItem.objects.create(category=c1) qs = CategoryItem.objects.exclude( category__onetoonecategory__isnull=True ).order_by("pk") self.assertEqual(qs.count(), 2) self.assertSequenceEqual(qs, [ci2, ci3]) class Queries5Tests(TestCase): @classmethod def setUpTestData(cls): # Ordering by 'rank' gives us rank2, rank1, rank3. Ordering by the # Meta.ordering will be rank3, rank2, rank1. cls.n1 = Note.objects.create(note="n1", misc="foo", id=1) cls.n2 = Note.objects.create(note="n2", misc="bar", id=2) e1 = ExtraInfo.objects.create(info="e1", note=cls.n1) e2 = ExtraInfo.objects.create(info="e2", note=cls.n2) a1 = Author.objects.create(name="a1", num=1001, extra=e1) a2 = Author.objects.create(name="a2", num=2002, extra=e1) a3 = Author.objects.create(name="a3", num=3003, extra=e2) cls.rank2 = Ranking.objects.create(rank=2, author=a2) cls.rank1 = Ranking.objects.create(rank=1, author=a3) cls.rank3 = Ranking.objects.create(rank=3, author=a1) def test_ordering(self): # Cross model ordering is possible in Meta, too. self.assertSequenceEqual( Ranking.objects.all(), [self.rank3, self.rank2, self.rank1], ) self.assertSequenceEqual( Ranking.objects.order_by("rank"), [self.rank1, self.rank2, self.rank3], ) # Ordering of extra() pieces is possible, too and you can mix extra # fields and model fields in the ordering. self.assertSequenceEqual( Ranking.objects.extra( tables=["django_site"], order_by=["-django_site.id", "rank"] ), [self.rank1, self.rank2, self.rank3], ) sql = "case when %s > 2 then 1 else 0 end" % connection.ops.quote_name("rank") qs = Ranking.objects.extra(select={"good": sql}) self.assertEqual( [o.good for o in qs.extra(order_by=("-good",))], [True, False, False] ) self.assertSequenceEqual( qs.extra(order_by=("-good", "id")), [self.rank3, self.rank2, self.rank1], ) # Despite having some extra aliases in the query, we can still omit # them in a values() query. dicts = qs.values("id", "rank").order_by("id") self.assertEqual([d["rank"] for d in dicts], [2, 1, 3]) def test_ticket7256(self): # An empty values() call includes all aliases, including those from an # extra() sql = "case when %s > 2 then 1 else 0 end" % connection.ops.quote_name("rank") qs = Ranking.objects.extra(select={"good": sql}) dicts = qs.values().order_by("id") for d in dicts: del d["id"] del d["author_id"] self.assertEqual( [sorted(d.items()) for d in dicts], [ [("good", 0), ("rank", 2)], [("good", 0), ("rank", 1)], [("good", 1), ("rank", 3)], ], ) def test_ticket7045(self): # Extra tables used to crash SQL construction on the second use. qs = Ranking.objects.extra(tables=["django_site"]) qs.query.get_compiler(qs.db).as_sql() # test passes if this doesn't raise an exception. qs.query.get_compiler(qs.db).as_sql() def test_ticket9848(self): # Make sure that updates which only filter on sub-tables don't # inadvertently update the wrong records (bug #9848). author_start = Author.objects.get(name="a1") ranking_start = Ranking.objects.get(author__name="a1") # Make sure that the IDs from different tables don't happen to match. self.assertSequenceEqual( Ranking.objects.filter(author__name="a1"), [self.rank3], ) self.assertEqual(Ranking.objects.filter(author__name="a1").update(rank=4636), 1) r = Ranking.objects.get(author__name="a1") self.assertEqual(r.id, ranking_start.id) self.assertEqual(r.author.id, author_start.id) self.assertEqual(r.rank, 4636) r.rank = 3 r.save() self.assertSequenceEqual( Ranking.objects.all(), [self.rank3, self.rank2, self.rank1], ) def test_ticket5261(self): # Test different empty excludes. self.assertSequenceEqual( Note.objects.exclude(Q()), [self.n1, self.n2], ) self.assertSequenceEqual( Note.objects.filter(~Q()), [self.n1, self.n2], ) self.assertSequenceEqual( Note.objects.filter(~Q() | ~Q()), [self.n1, self.n2], ) self.assertSequenceEqual( Note.objects.exclude(~Q() & ~Q()), [self.n1, self.n2], ) def test_extra_select_literal_percent_s(self): # Allow %%s to escape select clauses self.assertEqual(Note.objects.extra(select={"foo": "'%%s'"})[0].foo, "%s") self.assertEqual( Note.objects.extra(select={"foo": "'%%s bar %%s'"})[0].foo, "%s bar %s" ) self.assertEqual( Note.objects.extra(select={"foo": "'bar %%s'"})[0].foo, "bar %s" ) def test_queryset_reuse(self): # Using querysets doesn't mutate aliases. authors = Author.objects.filter(Q(name="a1") | Q(name="nonexistent")) self.assertEqual(Ranking.objects.filter(author__in=authors).get(), self.rank3) self.assertEqual(authors.count(), 1) def test_filter_unsaved_object(self): # These tests will catch ValueError in Django 5.0 when passing unsaved # model instances to related filters becomes forbidden. # msg = "Model instances passed to related filters must be saved." msg = "Passing unsaved model instances to related filters is deprecated." company = Company.objects.create(name="Django") with self.assertWarnsMessage(RemovedInDjango50Warning, msg): Employment.objects.filter(employer=Company(name="unsaved")) with self.assertWarnsMessage(RemovedInDjango50Warning, msg): Employment.objects.filter(employer__in=[company, Company(name="unsaved")]) with self.assertWarnsMessage(RemovedInDjango50Warning, msg): StaffUser.objects.filter(staff=Staff(name="unsaved")) class SelectRelatedTests(TestCase): def test_tickets_3045_3288(self): # Once upon a time, select_related() with circular relations would loop # infinitely if you forgot to specify "depth". Now we set an arbitrary # default upper bound. self.assertQuerysetEqual(X.objects.all(), []) self.assertQuerysetEqual(X.objects.select_related(), []) class SubclassFKTests(TestCase): def test_ticket7778(self): # Model subclasses could not be deleted if a nullable foreign key # relates to a model that relates back. num_celebs = Celebrity.objects.count() tvc = TvChef.objects.create(name="Huey") self.assertEqual(Celebrity.objects.count(), num_celebs + 1) Fan.objects.create(fan_of=tvc) Fan.objects.create(fan_of=tvc) tvc.delete() # The parent object should have been deleted as well. self.assertEqual(Celebrity.objects.count(), num_celebs) class CustomPkTests(TestCase): def test_ticket7371(self): self.assertQuerysetEqual(Related.objects.order_by("custom"), []) class NullableRelOrderingTests(TestCase): def test_ticket10028(self): # Ordering by model related to nullable relations(!) should use outer # joins, so that all results are included. p1 = Plaything.objects.create(name="p1") self.assertSequenceEqual(Plaything.objects.all(), [p1]) def test_join_already_in_query(self): # Ordering by model related to nullable relations should not change # the join type of already existing joins. Plaything.objects.create(name="p1") s = SingleObject.objects.create(name="s") r = RelatedObject.objects.create(single=s, f=1) p2 = Plaything.objects.create(name="p2", others=r) qs = Plaything.objects.filter(others__isnull=False).order_by("pk") self.assertNotIn("JOIN", str(qs.query)) qs = Plaything.objects.filter(others__f__isnull=False).order_by("pk") self.assertIn("INNER", str(qs.query)) qs = qs.order_by("others__single__name") # The ordering by others__single__pk will add one new join (to single) # and that join must be LEFT join. The already existing join to related # objects must be kept INNER. So, we have both an INNER and a LEFT join # in the query. self.assertEqual(str(qs.query).count("LEFT"), 1) self.assertEqual(str(qs.query).count("INNER"), 1) self.assertSequenceEqual(qs, [p2]) class DisjunctiveFilterTests(TestCase): @classmethod def setUpTestData(cls): cls.n1 = Note.objects.create(note="n1", misc="foo", id=1) cls.e1 = ExtraInfo.objects.create(info="e1", note=cls.n1) def test_ticket7872(self): # Another variation on the disjunctive filtering theme. # For the purposes of this regression test, it's important that there is no # Join object related to the LeafA we create. l1 = LeafA.objects.create(data="first") self.assertSequenceEqual(LeafA.objects.all(), [l1]) self.assertSequenceEqual( LeafA.objects.filter(Q(data="first") | Q(join__b__data="second")), [l1], ) def test_ticket8283(self): # Checking that applying filters after a disjunction works correctly. self.assertSequenceEqual( ( ExtraInfo.objects.filter(note=self.n1) | ExtraInfo.objects.filter(info="e2") ).filter(note=self.n1), [self.e1], ) self.assertSequenceEqual( ( ExtraInfo.objects.filter(info="e2") | ExtraInfo.objects.filter(note=self.n1) ).filter(note=self.n1), [self.e1], ) class Queries6Tests(TestCase): @classmethod def setUpTestData(cls): generic = NamedCategory.objects.create(name="Generic") cls.t1 = Tag.objects.create(name="t1", category=generic) cls.t2 = Tag.objects.create(name="t2", parent=cls.t1, category=generic) cls.t3 = Tag.objects.create(name="t3", parent=cls.t1) cls.t4 = Tag.objects.create(name="t4", parent=cls.t3) cls.t5 = Tag.objects.create(name="t5", parent=cls.t3) n1 = Note.objects.create(note="n1", misc="foo", id=1) cls.ann1 = Annotation.objects.create(name="a1", tag=cls.t1) cls.ann1.notes.add(n1) cls.ann2 = Annotation.objects.create(name="a2", tag=cls.t4) def test_parallel_iterators(self): # Parallel iterators work. qs = Tag.objects.all() i1, i2 = iter(qs), iter(qs) self.assertEqual(repr(next(i1)), "<Tag: t1>") self.assertEqual(repr(next(i1)), "<Tag: t2>") self.assertEqual(repr(next(i2)), "<Tag: t1>") self.assertEqual(repr(next(i2)), "<Tag: t2>") self.assertEqual(repr(next(i2)), "<Tag: t3>") self.assertEqual(repr(next(i1)), "<Tag: t3>") qs = X.objects.all() self.assertFalse(qs) self.assertFalse(qs) def test_nested_queries_sql(self): # Nested queries should not evaluate the inner query as part of constructing the # SQL (so we should see a nested query here, indicated by two "SELECT" calls). qs = Annotation.objects.filter(notes__in=Note.objects.filter(note="xyzzy")) self.assertEqual(qs.query.get_compiler(qs.db).as_sql()[0].count("SELECT"), 2) def test_tickets_8921_9188(self): # Incorrect SQL was being generated for certain types of exclude() # queries that crossed multi-valued relations (#8921, #9188 and some # preemptively discovered cases). self.assertSequenceEqual( PointerA.objects.filter(connection__pointerb__id=1), [] ) self.assertSequenceEqual( PointerA.objects.exclude(connection__pointerb__id=1), [] ) self.assertSequenceEqual( Tag.objects.exclude(children=None), [self.t1, self.t3], ) # This example is tricky because the parent could be NULL, so only checking # parents with annotations omits some results (tag t1, in this case). self.assertSequenceEqual( Tag.objects.exclude(parent__annotation__name="a1"), [self.t1, self.t4, self.t5], ) # The annotation->tag link is single values and tag->children links is # multi-valued. So we have to split the exclude filter in the middle # and then optimize the inner query without losing results. self.assertSequenceEqual( Annotation.objects.exclude(tag__children__name="t2"), [self.ann2], ) # Nested queries are possible (although should be used with care, since # they have performance problems on backends like MySQL. self.assertSequenceEqual( Annotation.objects.filter(notes__in=Note.objects.filter(note="n1")), [self.ann1], ) def test_ticket3739(self): # The all() method on querysets returns a copy of the queryset. q1 = Tag.objects.order_by("name") self.assertIsNot(q1, q1.all()) def test_ticket_11320(self): qs = Tag.objects.exclude(category=None).exclude(category__name="foo") self.assertEqual(str(qs.query).count(" INNER JOIN "), 1) def test_distinct_ordered_sliced_subquery_aggregation(self): self.assertEqual( Tag.objects.distinct().order_by("category__name")[:3].count(), 3 ) def test_multiple_columns_with_the_same_name_slice(self): self.assertEqual( list( Tag.objects.order_by("name").values_list("name", "category__name")[:2] ), [("t1", "Generic"), ("t2", "Generic")], ) self.assertSequenceEqual( Tag.objects.order_by("name").select_related("category")[:2], [self.t1, self.t2], ) self.assertEqual( list(Tag.objects.order_by("-name").values_list("name", "parent__name")[:2]), [("t5", "t3"), ("t4", "t3")], ) self.assertSequenceEqual( Tag.objects.order_by("-name").select_related("parent")[:2], [self.t5, self.t4], ) def test_col_alias_quoted(self): with CaptureQueriesContext(connection) as captured_queries: self.assertEqual( Tag.objects.values("parent") .annotate( tag_per_parent=Count("pk"), ) .aggregate(Max("tag_per_parent")), {"tag_per_parent__max": 2}, ) sql = captured_queries[0]["sql"] self.assertIn("AS %s" % connection.ops.quote_name("col1"), sql) class RawQueriesTests(TestCase): @classmethod def setUpTestData(cls): Note.objects.create(note="n1", misc="foo", id=1) def test_ticket14729(self): # Test representation of raw query with one or few parameters passed as list query = "SELECT * FROM queries_note WHERE note = %s" params = ["n1"] qs = Note.objects.raw(query, params=params) self.assertEqual( repr(qs), "<RawQuerySet: SELECT * FROM queries_note WHERE note = n1>" ) query = "SELECT * FROM queries_note WHERE note = %s and misc = %s" params = ["n1", "foo"] qs = Note.objects.raw(query, params=params) self.assertEqual( repr(qs), "<RawQuerySet: SELECT * FROM queries_note WHERE note = n1 and misc = foo>", ) class GeneratorExpressionTests(SimpleTestCase): def test_ticket10432(self): # Using an empty iterator as the rvalue for an "__in" # lookup is legal. self.assertCountEqual(Note.objects.filter(pk__in=iter(())), []) class ComparisonTests(TestCase): @classmethod def setUpTestData(cls): cls.n1 = Note.objects.create(note="n1", misc="foo", id=1) e1 = ExtraInfo.objects.create(info="e1", note=cls.n1) cls.a2 = Author.objects.create(name="a2", num=2002, extra=e1) def test_ticket8597(self): # Regression tests for case-insensitive comparisons item_ab = Item.objects.create( name="a_b", created=datetime.datetime.now(), creator=self.a2, note=self.n1 ) item_xy = Item.objects.create( name="x%y", created=datetime.datetime.now(), creator=self.a2, note=self.n1 ) self.assertSequenceEqual( Item.objects.filter(name__iexact="A_b"), [item_ab], ) self.assertSequenceEqual( Item.objects.filter(name__iexact="x%Y"), [item_xy], ) self.assertSequenceEqual( Item.objects.filter(name__istartswith="A_b"), [item_ab], ) self.assertSequenceEqual( Item.objects.filter(name__iendswith="A_b"), [item_ab], ) class ExistsSql(TestCase): def test_exists(self): with CaptureQueriesContext(connection) as captured_queries: self.assertFalse(Tag.objects.exists()) # Ok - so the exist query worked - but did it include too many columns? self.assertEqual(len(captured_queries), 1) qstr = captured_queries[0]["sql"] id, name = connection.ops.quote_name("id"), connection.ops.quote_name("name") self.assertNotIn(id, qstr) self.assertNotIn(name, qstr) def test_ticket_18414(self): Article.objects.create(name="one", created=datetime.datetime.now()) Article.objects.create(name="one", created=datetime.datetime.now()) Article.objects.create(name="two", created=datetime.datetime.now()) self.assertTrue(Article.objects.exists()) self.assertTrue(Article.objects.distinct().exists()) self.assertTrue(Article.objects.distinct()[1:3].exists()) self.assertFalse(Article.objects.distinct()[1:1].exists()) @skipUnlessDBFeature("can_distinct_on_fields") def test_ticket_18414_distinct_on(self): Article.objects.create(name="one", created=datetime.datetime.now()) Article.objects.create(name="one", created=datetime.datetime.now()) Article.objects.create(name="two", created=datetime.datetime.now()) self.assertTrue(Article.objects.distinct("name").exists()) self.assertTrue(Article.objects.distinct("name")[1:2].exists()) self.assertFalse(Article.objects.distinct("name")[2:3].exists()) class QuerysetOrderedTests(unittest.TestCase): """ Tests for the Queryset.ordered attribute. """ def test_no_default_or_explicit_ordering(self): self.assertIs(Annotation.objects.all().ordered, False) def test_cleared_default_ordering(self): self.assertIs(Tag.objects.all().ordered, True) self.assertIs(Tag.objects.order_by().ordered, False) def test_explicit_ordering(self): self.assertIs(Annotation.objects.order_by("id").ordered, True) def test_empty_queryset(self): self.assertIs(Annotation.objects.none().ordered, True) def test_order_by_extra(self): self.assertIs(Annotation.objects.extra(order_by=["id"]).ordered, True) def test_annotated_ordering(self): qs = Annotation.objects.annotate(num_notes=Count("notes")) self.assertIs(qs.ordered, False) self.assertIs(qs.order_by("num_notes").ordered, True) def test_annotated_default_ordering(self): qs = Tag.objects.annotate(num_notes=Count("pk")) self.assertIs(qs.ordered, False) self.assertIs(qs.order_by("name").ordered, True) def test_annotated_values_default_ordering(self): qs = Tag.objects.values("name").annotate(num_notes=Count("pk")) self.assertIs(qs.ordered, False) self.assertIs(qs.order_by("name").ordered, True) @skipUnlessDBFeature("allow_sliced_subqueries_with_in") class SubqueryTests(TestCase): @classmethod def setUpTestData(cls): NamedCategory.objects.create(id=1, name="first") NamedCategory.objects.create(id=2, name="second") NamedCategory.objects.create(id=3, name="third") NamedCategory.objects.create(id=4, name="fourth") def test_ordered_subselect(self): "Subselects honor any manual ordering" query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[0:2] ) self.assertEqual(set(query.values_list("id", flat=True)), {3, 4}) query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[:2] ) self.assertEqual(set(query.values_list("id", flat=True)), {3, 4}) query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[1:2] ) self.assertEqual(set(query.values_list("id", flat=True)), {3}) query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[2:] ) self.assertEqual(set(query.values_list("id", flat=True)), {1, 2}) def test_slice_subquery_and_query(self): """ Slice a query that has a sliced subquery """ query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[0:2] )[0:2] self.assertEqual({x.id for x in query}, {3, 4}) query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[1:3] )[1:3] self.assertEqual({x.id for x in query}, {3}) query = DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[2:] )[1:] self.assertEqual({x.id for x in query}, {2}) def test_related_sliced_subquery(self): """ Related objects constraints can safely contain sliced subqueries. refs #22434 """ generic = NamedCategory.objects.create(id=5, name="Generic") t1 = Tag.objects.create(name="t1", category=generic) t2 = Tag.objects.create(name="t2", category=generic) ManagedModel.objects.create(data="mm1", tag=t1, public=True) mm2 = ManagedModel.objects.create(data="mm2", tag=t2, public=True) query = ManagedModel.normal_manager.filter( tag__in=Tag.objects.order_by("-id")[:1] ) self.assertEqual({x.id for x in query}, {mm2.id}) def test_sliced_delete(self): "Delete queries can safely contain sliced subqueries" DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[0:1] ).delete() self.assertEqual( set(DumbCategory.objects.values_list("id", flat=True)), {1, 2, 3} ) DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[1:2] ).delete() self.assertEqual(set(DumbCategory.objects.values_list("id", flat=True)), {1, 3}) DumbCategory.objects.filter( id__in=DumbCategory.objects.order_by("-id")[1:] ).delete() self.assertEqual(set(DumbCategory.objects.values_list("id", flat=True)), {3}) def test_distinct_ordered_sliced_subquery(self): # Implicit values('id'). self.assertSequenceEqual( NamedCategory.objects.filter( id__in=NamedCategory.objects.distinct().order_by("name")[0:2], ) .order_by("name") .values_list("name", flat=True), ["first", "fourth"], ) # Explicit values('id'). self.assertSequenceEqual( NamedCategory.objects.filter( id__in=NamedCategory.objects.distinct() .order_by("-name") .values("id")[0:2], ) .order_by("name") .values_list("name", flat=True), ["second", "third"], ) # Annotated value. self.assertSequenceEqual( DumbCategory.objects.filter( id__in=DumbCategory.objects.annotate(double_id=F("id") * 2) .order_by("id") .distinct() .values("double_id")[0:2], ) .order_by("id") .values_list("id", flat=True), [2, 4], ) class QuerySetBitwiseOperationTests(TestCase): @classmethod def setUpTestData(cls): cls.school = School.objects.create() cls.room_1 = Classroom.objects.create( school=cls.school, has_blackboard=False, name="Room 1" ) cls.room_2 = Classroom.objects.create( school=cls.school, has_blackboard=True, name="Room 2" ) cls.room_3 = Classroom.objects.create( school=cls.school, has_blackboard=True, name="Room 3" ) cls.room_4 = Classroom.objects.create( school=cls.school, has_blackboard=False, name="Room 4" ) tag = Tag.objects.create() cls.annotation_1 = Annotation.objects.create(tag=tag) annotation_2 = Annotation.objects.create(tag=tag) note = cls.annotation_1.notes.create(tag=tag) cls.base_user_1 = BaseUser.objects.create(annotation=cls.annotation_1) cls.base_user_2 = BaseUser.objects.create(annotation=annotation_2) cls.task = Task.objects.create( owner=cls.base_user_2, creator=cls.base_user_2, note=note, ) @skipUnlessDBFeature("allow_sliced_subqueries_with_in") def test_or_with_rhs_slice(self): qs1 = Classroom.objects.filter(has_blackboard=True) qs2 = Classroom.objects.filter(has_blackboard=False)[:1] self.assertCountEqual(qs1 | qs2, [self.room_1, self.room_2, self.room_3]) @skipUnlessDBFeature("allow_sliced_subqueries_with_in") def test_or_with_lhs_slice(self): qs1 = Classroom.objects.filter(has_blackboard=True)[:1] qs2 = Classroom.objects.filter(has_blackboard=False) self.assertCountEqual(qs1 | qs2, [self.room_1, self.room_2, self.room_4]) @skipUnlessDBFeature("allow_sliced_subqueries_with_in") def test_or_with_both_slice(self): qs1 = Classroom.objects.filter(has_blackboard=False)[:1] qs2 = Classroom.objects.filter(has_blackboard=True)[:1] self.assertCountEqual(qs1 | qs2, [self.room_1, self.room_2]) @skipUnlessDBFeature("allow_sliced_subqueries_with_in") def test_or_with_both_slice_and_ordering(self): qs1 = Classroom.objects.filter(has_blackboard=False).order_by("-pk")[:1] qs2 = Classroom.objects.filter(has_blackboard=True).order_by("-name")[:1] self.assertCountEqual(qs1 | qs2, [self.room_3, self.room_4]) def test_subquery_aliases(self): combined = School.objects.filter(pk__isnull=False) & School.objects.filter( Exists( Classroom.objects.filter( has_blackboard=True, school=OuterRef("pk"), ) ), ) self.assertSequenceEqual(combined, [self.school]) nested_combined = School.objects.filter(pk__in=combined.values("pk")) self.assertSequenceEqual(nested_combined, [self.school]) def test_conflicting_aliases_during_combine(self): qs1 = self.annotation_1.baseuser_set.all() qs2 = BaseUser.objects.filter( Q(owner__note__in=self.annotation_1.notes.all()) | Q(creator__note__in=self.annotation_1.notes.all()) ) self.assertSequenceEqual(qs1, [self.base_user_1]) self.assertSequenceEqual(qs2, [self.base_user_2]) self.assertCountEqual(qs2 | qs1, qs1 | qs2) self.assertCountEqual(qs2 | qs1, [self.base_user_1, self.base_user_2]) class CloneTests(TestCase): def test_evaluated_queryset_as_argument(self): """ If a queryset is already evaluated, it can still be used as a query arg. """ n = Note(note="Test1", misc="misc") n.save() e = ExtraInfo(info="good", note=n) e.save() n_list = Note.objects.all() # Evaluate the Note queryset, populating the query cache list(n_list) # Make one of cached results unpickable. n_list._result_cache[0].lock = Lock() with self.assertRaises(TypeError): pickle.dumps(n_list) # Use the note queryset in a query, and evaluate # that query in a way that involves cloning. self.assertEqual(ExtraInfo.objects.filter(note__in=n_list)[0].info, "good") def test_no_model_options_cloning(self): """ Cloning a queryset does not get out of hand. While complete testing is impossible, this is a sanity check against invalid use of deepcopy. refs #16759. """ opts_class = type(Note._meta) note_deepcopy = getattr(opts_class, "__deepcopy__", None) opts_class.__deepcopy__ = lambda obj, memo: self.fail( "Model options shouldn't be cloned." ) try: Note.objects.filter(pk__lte=F("pk") + 1).all() finally: if note_deepcopy is None: delattr(opts_class, "__deepcopy__") else: opts_class.__deepcopy__ = note_deepcopy def test_no_fields_cloning(self): """ Cloning a queryset does not get out of hand. While complete testing is impossible, this is a sanity check against invalid use of deepcopy. refs #16759. """ opts_class = type(Note._meta.get_field("misc")) note_deepcopy = getattr(opts_class, "__deepcopy__", None) opts_class.__deepcopy__ = lambda obj, memo: self.fail( "Model fields shouldn't be cloned" ) try: Note.objects.filter(note=F("misc")).all() finally: if note_deepcopy is None: delattr(opts_class, "__deepcopy__") else: opts_class.__deepcopy__ = note_deepcopy class EmptyQuerySetTests(SimpleTestCase): def test_emptyqueryset_values(self): # #14366 -- Calling .values() on an empty QuerySet and then cloning # that should not cause an error self.assertCountEqual(Number.objects.none().values("num").order_by("num"), []) def test_values_subquery(self): self.assertCountEqual( Number.objects.filter(pk__in=Number.objects.none().values("pk")), [] ) self.assertCountEqual( Number.objects.filter(pk__in=Number.objects.none().values_list("pk")), [] ) def test_ticket_19151(self): # #19151 -- Calling .values() or .values_list() on an empty QuerySet # should return an empty QuerySet and not cause an error. q = Author.objects.none() self.assertCountEqual(q.values(), []) self.assertCountEqual(q.values_list(), []) class ValuesQuerysetTests(TestCase): @classmethod def setUpTestData(cls): Number.objects.create(num=72) def test_flat_values_list(self): qs = Number.objects.values_list("num") qs = qs.values_list("num", flat=True) self.assertSequenceEqual(qs, [72]) def test_extra_values(self): # testing for ticket 14930 issues qs = Number.objects.extra( select={"value_plus_x": "num+%s", "value_minus_x": "num-%s"}, select_params=(1, 2), ) qs = qs.order_by("value_minus_x") qs = qs.values("num") self.assertSequenceEqual(qs, [{"num": 72}]) def test_extra_values_order_twice(self): # testing for ticket 14930 issues qs = Number.objects.extra( select={"value_plus_one": "num+1", "value_minus_one": "num-1"} ) qs = qs.order_by("value_minus_one").order_by("value_plus_one") qs = qs.values("num") self.assertSequenceEqual(qs, [{"num": 72}]) def test_extra_values_order_multiple(self): # Postgres doesn't allow constants in order by, so check for that. qs = Number.objects.extra( select={ "value_plus_one": "num+1", "value_minus_one": "num-1", "constant_value": "1", } ) qs = qs.order_by("value_plus_one", "value_minus_one", "constant_value") qs = qs.values("num") self.assertSequenceEqual(qs, [{"num": 72}]) def test_extra_values_order_in_extra(self): # testing for ticket 14930 issues qs = Number.objects.extra( select={"value_plus_one": "num+1", "value_minus_one": "num-1"}, order_by=["value_minus_one"], ) qs = qs.values("num") def test_extra_select_params_values_order_in_extra(self): # testing for 23259 issue qs = Number.objects.extra( select={"value_plus_x": "num+%s"}, select_params=[1], order_by=["value_plus_x"], ) qs = qs.filter(num=72) qs = qs.values("num") self.assertSequenceEqual(qs, [{"num": 72}]) def test_extra_multiple_select_params_values_order_by(self): # testing for 23259 issue qs = Number.objects.extra( select={"value_plus_x": "num+%s", "value_minus_x": "num-%s"}, select_params=(72, 72), ) qs = qs.order_by("value_minus_x") qs = qs.filter(num=1) qs = qs.values("num") self.assertSequenceEqual(qs, []) def test_extra_values_list(self): # testing for ticket 14930 issues qs = Number.objects.extra(select={"value_plus_one": "num+1"}) qs = qs.order_by("value_plus_one") qs = qs.values_list("num") self.assertSequenceEqual(qs, [(72,)]) def test_flat_extra_values_list(self): # testing for ticket 14930 issues qs = Number.objects.extra(select={"value_plus_one": "num+1"}) qs = qs.order_by("value_plus_one") qs = qs.values_list("num", flat=True) self.assertSequenceEqual(qs, [72]) def test_field_error_values_list(self): # see #23443 msg = ( "Cannot resolve keyword %r into field. Join on 'name' not permitted." % "foo" ) with self.assertRaisesMessage(FieldError, msg): Tag.objects.values_list("name__foo") def test_named_values_list_flat(self): msg = "'flat' and 'named' can't be used together." with self.assertRaisesMessage(TypeError, msg): Number.objects.values_list("num", flat=True, named=True) def test_named_values_list_bad_field_name(self): msg = "Type names and field names must be valid identifiers: '1'" with self.assertRaisesMessage(ValueError, msg): Number.objects.extra(select={"1": "num+1"}).values_list( "1", named=True ).first() def test_named_values_list_with_fields(self): qs = Number.objects.extra(select={"num2": "num+1"}).annotate(Count("id")) values = qs.values_list("num", "num2", named=True).first() self.assertEqual(type(values).__name__, "Row") self.assertEqual(values._fields, ("num", "num2")) self.assertEqual(values.num, 72) self.assertEqual(values.num2, 73) def test_named_values_list_without_fields(self): qs = Number.objects.extra(select={"num2": "num+1"}).annotate(Count("id")) values = qs.values_list(named=True).first() self.assertEqual(type(values).__name__, "Row") self.assertEqual( values._fields, ("num2", "id", "num", "other_num", "another_num", "id__count"), ) self.assertEqual(values.num, 72) self.assertEqual(values.num2, 73) self.assertEqual(values.id__count, 1) def test_named_values_list_expression_with_default_alias(self): expr = Count("id") values = ( Number.objects.annotate(id__count1=expr) .values_list(expr, "id__count1", named=True) .first() ) self.assertEqual(values._fields, ("id__count2", "id__count1")) def test_named_values_list_expression(self): expr = F("num") + 1 qs = Number.objects.annotate(combinedexpression1=expr).values_list( expr, "combinedexpression1", named=True ) values = qs.first() self.assertEqual(values._fields, ("combinedexpression2", "combinedexpression1")) def test_named_values_pickle(self): value = Number.objects.values_list("num", "other_num", named=True).get() self.assertEqual(value, (72, None)) self.assertEqual(pickle.loads(pickle.dumps(value)), value) class QuerySetSupportsPythonIdioms(TestCase): @classmethod def setUpTestData(cls): some_date = datetime.datetime(2014, 5, 16, 12, 1) cls.articles = [ Article.objects.create(name=f"Article {i}", created=some_date) for i in range(1, 8) ] def get_ordered_articles(self): return Article.objects.order_by("name") def test_can_get_items_using_index_and_slice_notation(self): self.assertEqual(self.get_ordered_articles()[0].name, "Article 1") self.assertSequenceEqual( self.get_ordered_articles()[1:3], [self.articles[1], self.articles[2]], ) def test_slicing_with_steps_can_be_used(self): self.assertSequenceEqual( self.get_ordered_articles()[::2], [ self.articles[0], self.articles[2], self.articles[4], self.articles[6], ], ) def test_slicing_without_step_is_lazy(self): with self.assertNumQueries(0): self.get_ordered_articles()[0:5] def test_slicing_with_tests_is_not_lazy(self): with self.assertNumQueries(1): self.get_ordered_articles()[0:5:3] def test_slicing_can_slice_again_after_slicing(self): self.assertSequenceEqual( self.get_ordered_articles()[0:5][0:2], [self.articles[0], self.articles[1]], ) self.assertSequenceEqual( self.get_ordered_articles()[0:5][4:], [self.articles[4]] ) self.assertSequenceEqual(self.get_ordered_articles()[0:5][5:], []) # Some more tests! self.assertSequenceEqual( self.get_ordered_articles()[2:][0:2], [self.articles[2], self.articles[3]], ) self.assertSequenceEqual( self.get_ordered_articles()[2:][:2], [self.articles[2], self.articles[3]], ) self.assertSequenceEqual( self.get_ordered_articles()[2:][2:3], [self.articles[4]] ) # Using an offset without a limit is also possible. self.assertSequenceEqual( self.get_ordered_articles()[5:], [self.articles[5], self.articles[6]], ) def test_slicing_cannot_filter_queryset_once_sliced(self): msg = "Cannot filter a query once a slice has been taken." with self.assertRaisesMessage(TypeError, msg): Article.objects.all()[0:5].filter(id=1) def test_slicing_cannot_reorder_queryset_once_sliced(self): msg = "Cannot reorder a query once a slice has been taken." with self.assertRaisesMessage(TypeError, msg): Article.objects.all()[0:5].order_by("id") def test_slicing_cannot_combine_queries_once_sliced(self): msg = "Cannot combine queries once a slice has been taken." with self.assertRaisesMessage(TypeError, msg): Article.objects.all()[0:1] & Article.objects.all()[4:5] def test_slicing_negative_indexing_not_supported_for_single_element(self): """hint: inverting your ordering might do what you need""" msg = "Negative indexing is not supported." with self.assertRaisesMessage(ValueError, msg): Article.objects.all()[-1] def test_slicing_negative_indexing_not_supported_for_range(self): """hint: inverting your ordering might do what you need""" msg = "Negative indexing is not supported." with self.assertRaisesMessage(ValueError, msg): Article.objects.all()[0:-5] with self.assertRaisesMessage(ValueError, msg): Article.objects.all()[-1:] def test_invalid_index(self): msg = "QuerySet indices must be integers or slices, not str." with self.assertRaisesMessage(TypeError, msg): Article.objects.all()["foo"] def test_can_get_number_of_items_in_queryset_using_standard_len(self): self.assertEqual(len(Article.objects.filter(name__exact="Article 1")), 1) def test_can_combine_queries_using_and_and_or_operators(self): s1 = Article.objects.filter(name__exact="Article 1") s2 = Article.objects.filter(name__exact="Article 2") self.assertSequenceEqual( (s1 | s2).order_by("name"), [self.articles[0], self.articles[1]], ) self.assertSequenceEqual(s1 & s2, []) class WeirdQuerysetSlicingTests(TestCase): @classmethod def setUpTestData(cls): Number.objects.create(num=1) Number.objects.create(num=2) Article.objects.create(name="one", created=datetime.datetime.now()) Article.objects.create(name="two", created=datetime.datetime.now()) Article.objects.create(name="three", created=datetime.datetime.now()) Article.objects.create(name="four", created=datetime.datetime.now()) food = Food.objects.create(name="spam") Eaten.objects.create(meal="spam with eggs", food=food) def test_tickets_7698_10202(self): # People like to slice with '0' as the high-water mark. self.assertQuerysetEqual(Article.objects.all()[0:0], []) self.assertQuerysetEqual(Article.objects.all()[0:0][:10], []) self.assertEqual(Article.objects.all()[:0].count(), 0) msg = "Cannot change a query once a slice has been taken." with self.assertRaisesMessage(TypeError, msg): Article.objects.all()[:0].latest("created") def test_empty_resultset_sql(self): # ticket #12192 self.assertNumQueries(0, lambda: list(Number.objects.all()[1:1])) def test_empty_sliced_subquery(self): self.assertEqual( Eaten.objects.filter(food__in=Food.objects.all()[0:0]).count(), 0 ) def test_empty_sliced_subquery_exclude(self): self.assertEqual( Eaten.objects.exclude(food__in=Food.objects.all()[0:0]).count(), 1 ) def test_zero_length_values_slicing(self): n = 42 with self.assertNumQueries(0): self.assertQuerysetEqual(Article.objects.values()[n:n], []) self.assertQuerysetEqual(Article.objects.values_list()[n:n], []) class EscapingTests(TestCase): def test_ticket_7302(self): # Reserved names are appropriately escaped r_a = ReservedName.objects.create(name="a", order=42) r_b = ReservedName.objects.create(name="b", order=37) self.assertSequenceEqual( ReservedName.objects.order_by("order"), [r_b, r_a], ) self.assertSequenceEqual( ReservedName.objects.extra( select={"stuff": "name"}, order_by=("order", "stuff") ), [r_b, r_a], ) class ToFieldTests(TestCase): def test_in_query(self): apple = Food.objects.create(name="apple") pear = Food.objects.create(name="pear") lunch = Eaten.objects.create(food=apple, meal="lunch") dinner = Eaten.objects.create(food=pear, meal="dinner") self.assertEqual( set(Eaten.objects.filter(food__in=[apple, pear])), {lunch, dinner}, ) def test_in_subquery(self): apple = Food.objects.create(name="apple") lunch = Eaten.objects.create(food=apple, meal="lunch") self.assertEqual( set(Eaten.objects.filter(food__in=Food.objects.filter(name="apple"))), {lunch}, ) self.assertEqual( set( Eaten.objects.filter( food__in=Food.objects.filter(name="apple").values("eaten__meal") ) ), set(), ) self.assertEqual( set(Food.objects.filter(eaten__in=Eaten.objects.filter(meal="lunch"))), {apple}, ) def test_nested_in_subquery(self): extra = ExtraInfo.objects.create() author = Author.objects.create(num=42, extra=extra) report = Report.objects.create(creator=author) comment = ReportComment.objects.create(report=report) comments = ReportComment.objects.filter( report__in=Report.objects.filter( creator__in=extra.author_set.all(), ), ) self.assertSequenceEqual(comments, [comment]) def test_reverse_in(self): apple = Food.objects.create(name="apple") pear = Food.objects.create(name="pear") lunch_apple = Eaten.objects.create(food=apple, meal="lunch") lunch_pear = Eaten.objects.create(food=pear, meal="dinner") self.assertEqual( set(Food.objects.filter(eaten__in=[lunch_apple, lunch_pear])), {apple, pear} ) def test_single_object(self): apple = Food.objects.create(name="apple") lunch = Eaten.objects.create(food=apple, meal="lunch") dinner = Eaten.objects.create(food=apple, meal="dinner") self.assertEqual(set(Eaten.objects.filter(food=apple)), {lunch, dinner}) def test_single_object_reverse(self): apple = Food.objects.create(name="apple") lunch = Eaten.objects.create(food=apple, meal="lunch") self.assertEqual(set(Food.objects.filter(eaten=lunch)), {apple}) def test_recursive_fk(self): node1 = Node.objects.create(num=42) node2 = Node.objects.create(num=1, parent=node1) self.assertEqual(list(Node.objects.filter(parent=node1)), [node2]) def test_recursive_fk_reverse(self): node1 = Node.objects.create(num=42) node2 = Node.objects.create(num=1, parent=node1) self.assertEqual(list(Node.objects.filter(node=node2)), [node1]) class IsNullTests(TestCase): def test_primary_key(self): custom = CustomPk.objects.create(name="pk") null = Related.objects.create() notnull = Related.objects.create(custom=custom) self.assertSequenceEqual( Related.objects.filter(custom__isnull=False), [notnull] ) self.assertSequenceEqual(Related.objects.filter(custom__isnull=True), [null]) def test_to_field(self): apple = Food.objects.create(name="apple") e1 = Eaten.objects.create(food=apple, meal="lunch") e2 = Eaten.objects.create(meal="lunch") self.assertSequenceEqual( Eaten.objects.filter(food__isnull=False), [e1], ) self.assertSequenceEqual( Eaten.objects.filter(food__isnull=True), [e2], ) class ConditionalTests(TestCase): """Tests whose execution depend on different environment conditions like Python version or DB backend features""" @classmethod def setUpTestData(cls): generic = NamedCategory.objects.create(name="Generic") t1 = Tag.objects.create(name="t1", category=generic) Tag.objects.create(name="t2", parent=t1, category=generic) t3 = Tag.objects.create(name="t3", parent=t1) Tag.objects.create(name="t4", parent=t3) Tag.objects.create(name="t5", parent=t3) def test_infinite_loop(self): # If you're not careful, it's possible to introduce infinite loops via # default ordering on foreign keys in a cycle. We detect that. with self.assertRaisesMessage(FieldError, "Infinite loop caused by ordering."): list(LoopX.objects.all()) # Force queryset evaluation with list() with self.assertRaisesMessage(FieldError, "Infinite loop caused by ordering."): list(LoopZ.objects.all()) # Force queryset evaluation with list() # Note that this doesn't cause an infinite loop, since the default # ordering on the Tag model is empty (and thus defaults to using "id" # for the related field). self.assertEqual(len(Tag.objects.order_by("parent")), 5) # ... but you can still order in a non-recursive fashion among linked # fields (the previous test failed because the default ordering was # recursive). self.assertQuerysetEqual(LoopX.objects.order_by("y__x__y__x__id"), []) # When grouping without specifying ordering, we add an explicit "ORDER BY NULL" # portion in MySQL to prevent unnecessary sorting. @skipUnlessDBFeature("requires_explicit_null_ordering_when_grouping") def test_null_ordering_added(self): query = Tag.objects.values_list("parent_id", flat=True).order_by().query query.group_by = ["parent_id"] sql = query.get_compiler(DEFAULT_DB_ALIAS).as_sql()[0] fragment = "ORDER BY " pos = sql.find(fragment) self.assertEqual(sql.find(fragment, pos + 1), -1) self.assertEqual(sql.find("NULL", pos + len(fragment)), pos + len(fragment)) def test_in_list_limit(self): # The "in" lookup works with lists of 1000 items or more. # The numbers amount is picked to force three different IN batches # for Oracle, yet to be less than 2100 parameter limit for MSSQL. numbers = list(range(2050)) max_query_params = connection.features.max_query_params if max_query_params is None or max_query_params >= len(numbers): Number.objects.bulk_create(Number(num=num) for num in numbers) for number in [1000, 1001, 2000, len(numbers)]: with self.subTest(number=number): self.assertEqual( Number.objects.filter(num__in=numbers[:number]).count(), number ) class UnionTests(unittest.TestCase): """ Tests for the union of two querysets. Bug #12252. """ @classmethod def setUpTestData(cls): objectas = [] objectbs = [] objectcs = [] a_info = ["one", "two", "three"] for name in a_info: o = ObjectA(name=name) o.save() objectas.append(o) b_info = [ ("un", 1, objectas[0]), ("deux", 2, objectas[0]), ("trois", 3, objectas[2]), ] for name, number, objecta in b_info: o = ObjectB(name=name, num=number, objecta=objecta) o.save() objectbs.append(o) c_info = [("ein", objectas[2], objectbs[2]), ("zwei", objectas[1], objectbs[1])] for name, objecta, objectb in c_info: o = ObjectC(name=name, objecta=objecta, objectb=objectb) o.save() objectcs.append(o) def check_union(self, model, Q1, Q2): filter = model.objects.filter self.assertEqual(set(filter(Q1) | filter(Q2)), set(filter(Q1 | Q2))) self.assertEqual(set(filter(Q2) | filter(Q1)), set(filter(Q1 | Q2))) def test_A_AB(self): Q1 = Q(name="two") Q2 = Q(objectb__name="deux") self.check_union(ObjectA, Q1, Q2) def test_A_AB2(self): Q1 = Q(name="two") Q2 = Q(objectb__name="deux", objectb__num=2) self.check_union(ObjectA, Q1, Q2) def test_AB_ACB(self): Q1 = Q(objectb__name="deux") Q2 = Q(objectc__objectb__name="deux") self.check_union(ObjectA, Q1, Q2) def test_BAB_BAC(self): Q1 = Q(objecta__objectb__name="deux") Q2 = Q(objecta__objectc__name="ein") self.check_union(ObjectB, Q1, Q2) def test_BAB_BACB(self): Q1 = Q(objecta__objectb__name="deux") Q2 = Q(objecta__objectc__objectb__name="trois") self.check_union(ObjectB, Q1, Q2) def test_BA_BCA__BAB_BAC_BCA(self): Q1 = Q(objecta__name="one", objectc__objecta__name="two") Q2 = Q( objecta__objectc__name="ein", objectc__objecta__name="three", objecta__objectb__name="trois", ) self.check_union(ObjectB, Q1, Q2) class DefaultValuesInsertTest(TestCase): def test_no_extra_params(self): """ Can create an instance of a model with only the PK field (#17056)." """ DumbCategory.objects.create() class ExcludeTests(TestCase): @classmethod def setUpTestData(cls): f1 = Food.objects.create(name="apples") cls.f2 = Food.objects.create(name="oranges") Eaten.objects.create(food=f1, meal="dinner") cls.j1 = Job.objects.create(name="Manager") cls.r1 = Responsibility.objects.create(description="Playing golf") cls.j2 = Job.objects.create(name="Programmer") cls.r2 = Responsibility.objects.create(description="Programming") JobResponsibilities.objects.create(job=cls.j1, responsibility=cls.r1) JobResponsibilities.objects.create(job=cls.j2, responsibility=cls.r2) def test_to_field(self): self.assertSequenceEqual( Food.objects.exclude(eaten__meal="dinner"), [self.f2], ) self.assertSequenceEqual( Job.objects.exclude(responsibilities__description="Playing golf"), [self.j2], ) self.assertSequenceEqual( Responsibility.objects.exclude(jobs__name="Manager"), [self.r2], ) def test_ticket14511(self): alex = Person.objects.get_or_create(name="Alex")[0] jane = Person.objects.get_or_create(name="Jane")[0] oracle = Company.objects.get_or_create(name="Oracle")[0] google = Company.objects.get_or_create(name="Google")[0] microsoft = Company.objects.get_or_create(name="Microsoft")[0] intel = Company.objects.get_or_create(name="Intel")[0] def employ(employer, employee, title): Employment.objects.get_or_create( employee=employee, employer=employer, title=title ) employ(oracle, alex, "Engineer") employ(oracle, alex, "Developer") employ(google, alex, "Engineer") employ(google, alex, "Manager") employ(microsoft, alex, "Manager") employ(intel, alex, "Manager") employ(microsoft, jane, "Developer") employ(intel, jane, "Manager") alex_tech_employers = ( alex.employers.filter(employment__title__in=("Engineer", "Developer")) .distinct() .order_by("name") ) self.assertSequenceEqual(alex_tech_employers, [google, oracle]) alex_nontech_employers = ( alex.employers.exclude(employment__title__in=("Engineer", "Developer")) .distinct() .order_by("name") ) self.assertSequenceEqual(alex_nontech_employers, [google, intel, microsoft]) def test_exclude_reverse_fk_field_ref(self): tag = Tag.objects.create() Note.objects.create(tag=tag, note="note") annotation = Annotation.objects.create(name="annotation", tag=tag) self.assertEqual( Annotation.objects.exclude(tag__note__note=F("name")).get(), annotation ) def test_exclude_with_circular_fk_relation(self): self.assertEqual( ObjectB.objects.exclude(objecta__objectb__name=F("name")).count(), 0 ) def test_subquery_exclude_outerref(self): qs = JobResponsibilities.objects.filter( Exists(Responsibility.objects.exclude(jobs=OuterRef("job"))), ) self.assertTrue(qs.exists()) self.r1.delete() self.assertFalse(qs.exists()) def test_exclude_nullable_fields(self): number = Number.objects.create(num=1, other_num=1) Number.objects.create(num=2, other_num=2, another_num=2) self.assertSequenceEqual( Number.objects.exclude(other_num=F("another_num")), [number], ) self.assertSequenceEqual( Number.objects.exclude(num=F("another_num")), [number], ) def test_exclude_multivalued_exists(self): with CaptureQueriesContext(connection) as captured_queries: self.assertSequenceEqual( Job.objects.exclude(responsibilities__description="Programming"), [self.j1], ) self.assertIn("exists", captured_queries[0]["sql"].lower()) def test_exclude_subquery(self): subquery = JobResponsibilities.objects.filter( responsibility__description="bar", ) | JobResponsibilities.objects.exclude( job__responsibilities__description="foo", ) self.assertCountEqual( Job.objects.annotate( responsibility=subquery.filter(job=OuterRef("name"),).values( "id" )[:1] ), [self.j1, self.j2], ) @ignore_warnings(category=RemovedInDjango50Warning) def test_exclude_unsaved_o2o_object(self): jack = Staff.objects.create(name="jack") jack_staff = StaffUser.objects.create(staff=jack) unsaved_object = Staff(name="jane") self.assertIsNone(unsaved_object.pk) self.assertSequenceEqual( StaffUser.objects.exclude(staff=unsaved_object), [jack_staff] ) def test_exclude_unsaved_object(self): # These tests will catch ValueError in Django 5.0 when passing unsaved # model instances to related filters becomes forbidden. # msg = "Model instances passed to related filters must be saved." company = Company.objects.create(name="Django") msg = "Passing unsaved model instances to related filters is deprecated." with self.assertWarnsMessage(RemovedInDjango50Warning, msg): Employment.objects.exclude(employer=Company(name="unsaved")) with self.assertWarnsMessage(RemovedInDjango50Warning, msg): Employment.objects.exclude(employer__in=[company, Company(name="unsaved")]) with self.assertWarnsMessage(RemovedInDjango50Warning, msg): StaffUser.objects.exclude(staff=Staff(name="unsaved")) class ExcludeTest17600(TestCase): """ Some regressiontests for ticket #17600. Some of these likely duplicate other existing tests. """ @classmethod def setUpTestData(cls): # Create a few Orders. cls.o1 = Order.objects.create(pk=1) cls.o2 = Order.objects.create(pk=2) cls.o3 = Order.objects.create(pk=3) # Create some OrderItems for the first order with homogeneous # status_id values cls.oi1 = OrderItem.objects.create(order=cls.o1, status=1) cls.oi2 = OrderItem.objects.create(order=cls.o1, status=1) cls.oi3 = OrderItem.objects.create(order=cls.o1, status=1) # Create some OrderItems for the second order with heterogeneous # status_id values cls.oi4 = OrderItem.objects.create(order=cls.o2, status=1) cls.oi5 = OrderItem.objects.create(order=cls.o2, status=2) cls.oi6 = OrderItem.objects.create(order=cls.o2, status=3) # Create some OrderItems for the second order with heterogeneous # status_id values cls.oi7 = OrderItem.objects.create(order=cls.o3, status=2) cls.oi8 = OrderItem.objects.create(order=cls.o3, status=3) cls.oi9 = OrderItem.objects.create(order=cls.o3, status=4) def test_exclude_plain(self): """ This should exclude Orders which have some items with status 1 """ self.assertSequenceEqual( Order.objects.exclude(items__status=1), [self.o3], ) def test_exclude_plain_distinct(self): """ This should exclude Orders which have some items with status 1 """ self.assertSequenceEqual( Order.objects.exclude(items__status=1).distinct(), [self.o3], ) def test_exclude_with_q_object_distinct(self): """ This should exclude Orders which have some items with status 1 """ self.assertSequenceEqual( Order.objects.exclude(Q(items__status=1)).distinct(), [self.o3], ) def test_exclude_with_q_object_no_distinct(self): """ This should exclude Orders which have some items with status 1 """ self.assertSequenceEqual( Order.objects.exclude(Q(items__status=1)), [self.o3], ) def test_exclude_with_q_is_equal_to_plain_exclude(self): """ Using exclude(condition) and exclude(Q(condition)) should yield the same QuerySet """ self.assertEqual( list(Order.objects.exclude(items__status=1).distinct()), list(Order.objects.exclude(Q(items__status=1)).distinct()), ) def test_exclude_with_q_is_equal_to_plain_exclude_variation(self): """ Using exclude(condition) and exclude(Q(condition)) should yield the same QuerySet """ self.assertEqual( list(Order.objects.exclude(items__status=1)), list(Order.objects.exclude(Q(items__status=1)).distinct()), ) @unittest.expectedFailure def test_only_orders_with_all_items_having_status_1(self): """ This should only return orders having ALL items set to status 1, or those items not having any orders at all. The correct way to write this query in SQL seems to be using two nested subqueries. """ self.assertQuerysetEqual( Order.objects.exclude(~Q(items__status=1)).distinct(), [self.o1], ) class Exclude15786(TestCase): """Regression test for #15786""" def test_ticket15786(self): c1 = SimpleCategory.objects.create(name="c1") c2 = SimpleCategory.objects.create(name="c2") OneToOneCategory.objects.create(category=c1) OneToOneCategory.objects.create(category=c2) rel = CategoryRelationship.objects.create(first=c1, second=c2) self.assertEqual( CategoryRelationship.objects.exclude( first__onetoonecategory=F("second__onetoonecategory") ).get(), rel, ) class NullInExcludeTest(TestCase): @classmethod def setUpTestData(cls): NullableName.objects.create(name="i1") NullableName.objects.create() def test_null_in_exclude_qs(self): none_val = "" if connection.features.interprets_empty_strings_as_nulls else None self.assertQuerysetEqual( NullableName.objects.exclude(name__in=[]), ["i1", none_val], attrgetter("name"), ) self.assertQuerysetEqual( NullableName.objects.exclude(name__in=["i1"]), [none_val], attrgetter("name"), ) self.assertQuerysetEqual( NullableName.objects.exclude(name__in=["i3"]), ["i1", none_val], attrgetter("name"), ) inner_qs = NullableName.objects.filter(name="i1").values_list("name") self.assertQuerysetEqual( NullableName.objects.exclude(name__in=inner_qs), [none_val], attrgetter("name"), ) # The inner queryset wasn't executed - it should be turned # into subquery above self.assertIs(inner_qs._result_cache, None) @unittest.expectedFailure def test_col_not_in_list_containing_null(self): """ The following case is not handled properly because SQL's COL NOT IN (list containing null) handling is too weird to abstract away. """ self.assertQuerysetEqual( NullableName.objects.exclude(name__in=[None]), ["i1"], attrgetter("name") ) def test_double_exclude(self): self.assertEqual( list(NullableName.objects.filter(~~Q(name="i1"))), list(NullableName.objects.filter(Q(name="i1"))), ) self.assertNotIn( "IS NOT NULL", str(NullableName.objects.filter(~~Q(name="i1")).query) ) class EmptyStringsAsNullTest(TestCase): """ Filtering on non-null character fields works as expected. The reason for these tests is that Oracle treats '' as NULL, and this can cause problems in query construction. Refs #17957. """ @classmethod def setUpTestData(cls): cls.nc = NamedCategory.objects.create(name="") def test_direct_exclude(self): self.assertQuerysetEqual( NamedCategory.objects.exclude(name__in=["nonexistent"]), [self.nc.pk], attrgetter("pk"), ) def test_joined_exclude(self): self.assertQuerysetEqual( DumbCategory.objects.exclude(namedcategory__name__in=["nonexistent"]), [self.nc.pk], attrgetter("pk"), ) def test_21001(self): foo = NamedCategory.objects.create(name="foo") self.assertQuerysetEqual( NamedCategory.objects.exclude(name=""), [foo.pk], attrgetter("pk") ) class ProxyQueryCleanupTest(TestCase): def test_evaluated_proxy_count(self): """ Generating the query string doesn't alter the query's state in irreversible ways. Refs #18248. """ ProxyCategory.objects.create() qs = ProxyCategory.objects.all() self.assertEqual(qs.count(), 1) str(qs.query) self.assertEqual(qs.count(), 1) class WhereNodeTest(SimpleTestCase): class DummyNode: def as_sql(self, compiler, connection): return "dummy", [] class MockCompiler: def compile(self, node): return node.as_sql(self, connection) def __call__(self, name): return connection.ops.quote_name(name) def test_empty_full_handling_conjunction(self): compiler = WhereNodeTest.MockCompiler() w = WhereNode(children=[NothingNode()]) with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("", [])) w = WhereNode(children=[self.DummyNode(), self.DummyNode()]) self.assertEqual(w.as_sql(compiler, connection), ("(dummy AND dummy)", [])) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("NOT (dummy AND dummy)", [])) w = WhereNode(children=[NothingNode(), self.DummyNode()]) with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("", [])) def test_empty_full_handling_disjunction(self): compiler = WhereNodeTest.MockCompiler() w = WhereNode(children=[NothingNode()], connector="OR") with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("", [])) w = WhereNode(children=[self.DummyNode(), self.DummyNode()], connector="OR") self.assertEqual(w.as_sql(compiler, connection), ("(dummy OR dummy)", [])) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("NOT (dummy OR dummy)", [])) w = WhereNode(children=[NothingNode(), self.DummyNode()], connector="OR") self.assertEqual(w.as_sql(compiler, connection), ("dummy", [])) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("NOT (dummy)", [])) def test_empty_nodes(self): compiler = WhereNodeTest.MockCompiler() empty_w = WhereNode() w = WhereNode(children=[empty_w, empty_w]) self.assertEqual(w.as_sql(compiler, connection), ("", [])) w.negate() with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) w.connector = "OR" with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) w.negate() self.assertEqual(w.as_sql(compiler, connection), ("", [])) w = WhereNode(children=[empty_w, NothingNode()], connector="OR") self.assertEqual(w.as_sql(compiler, connection), ("", [])) w = WhereNode(children=[empty_w, NothingNode()], connector="AND") with self.assertRaises(EmptyResultSet): w.as_sql(compiler, connection) class QuerySetExceptionTests(SimpleTestCase): def test_iter_exceptions(self): qs = ExtraInfo.objects.only("author") msg = "'ManyToOneRel' object has no attribute 'attname'" with self.assertRaisesMessage(AttributeError, msg): list(qs) def test_invalid_order_by(self): msg = "Cannot resolve keyword '*' into field. Choices are: created, id, name" with self.assertRaisesMessage(FieldError, msg): Article.objects.order_by("*") def test_invalid_order_by_raw_column_alias(self): msg = ( "Cannot resolve keyword 'queries_author.name' into field. Choices " "are: cover, created, creator, creator_id, id, modified, name, " "note, note_id, tags" ) with self.assertRaisesMessage(FieldError, msg): Item.objects.values("creator__name").order_by("queries_author.name") def test_invalid_queryset_model(self): msg = 'Cannot use QuerySet for "Article": Use a QuerySet for "ExtraInfo".' with self.assertRaisesMessage(ValueError, msg): list(Author.objects.filter(extra=Article.objects.all())) class NullJoinPromotionOrTest(TestCase): @classmethod def setUpTestData(cls): cls.d1 = ModelD.objects.create(name="foo") d2 = ModelD.objects.create(name="bar") cls.a1 = ModelA.objects.create(name="a1", d=cls.d1) c = ModelC.objects.create(name="c") b = ModelB.objects.create(name="b", c=c) cls.a2 = ModelA.objects.create(name="a2", b=b, d=d2) def test_ticket_17886(self): # The first Q-object is generating the match, the rest of the filters # should not remove the match even if they do not match anything. The # problem here was that b__name generates a LOUTER JOIN, then # b__c__name generates join to c, which the ORM tried to promote but # failed as that join isn't nullable. q_obj = Q(d__name="foo") | Q(b__name="foo") | Q(b__c__name="foo") qset = ModelA.objects.filter(q_obj) self.assertEqual(list(qset), [self.a1]) # We generate one INNER JOIN to D. The join is direct and not nullable # so we can use INNER JOIN for it. However, we can NOT use INNER JOIN # for the b->c join, as a->b is nullable. self.assertEqual(str(qset.query).count("INNER JOIN"), 1) def test_isnull_filter_promotion(self): qs = ModelA.objects.filter(Q(b__name__isnull=True)) self.assertEqual(str(qs.query).count("LEFT OUTER"), 1) self.assertEqual(list(qs), [self.a1]) qs = ModelA.objects.filter(~Q(b__name__isnull=True)) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(list(qs), [self.a2]) qs = ModelA.objects.filter(~~Q(b__name__isnull=True)) self.assertEqual(str(qs.query).count("LEFT OUTER"), 1) self.assertEqual(list(qs), [self.a1]) qs = ModelA.objects.filter(Q(b__name__isnull=False)) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(list(qs), [self.a2]) qs = ModelA.objects.filter(~Q(b__name__isnull=False)) self.assertEqual(str(qs.query).count("LEFT OUTER"), 1) self.assertEqual(list(qs), [self.a1]) qs = ModelA.objects.filter(~~Q(b__name__isnull=False)) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(list(qs), [self.a2]) def test_null_join_demotion(self): qs = ModelA.objects.filter(Q(b__name__isnull=False) & Q(b__name__isnull=True)) self.assertIn(" INNER JOIN ", str(qs.query)) qs = ModelA.objects.filter(Q(b__name__isnull=True) & Q(b__name__isnull=False)) self.assertIn(" INNER JOIN ", str(qs.query)) qs = ModelA.objects.filter(Q(b__name__isnull=False) | Q(b__name__isnull=True)) self.assertIn(" LEFT OUTER JOIN ", str(qs.query)) qs = ModelA.objects.filter(Q(b__name__isnull=True) | Q(b__name__isnull=False)) self.assertIn(" LEFT OUTER JOIN ", str(qs.query)) def test_ticket_21366(self): n = Note.objects.create(note="n", misc="m") e = ExtraInfo.objects.create(info="info", note=n) a = Author.objects.create(name="Author1", num=1, extra=e) Ranking.objects.create(rank=1, author=a) r1 = Report.objects.create(name="Foo", creator=a) r2 = Report.objects.create(name="Bar") Report.objects.create(name="Bar", creator=a) qs = Report.objects.filter( Q(creator__ranking__isnull=True) | Q(creator__ranking__rank=1, name="Foo") ) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) self.assertEqual(str(qs.query).count(" JOIN "), 2) self.assertSequenceEqual(qs.order_by("name"), [r2, r1]) def test_ticket_21748(self): i1 = Identifier.objects.create(name="i1") i2 = Identifier.objects.create(name="i2") i3 = Identifier.objects.create(name="i3") Program.objects.create(identifier=i1) Channel.objects.create(identifier=i1) Program.objects.create(identifier=i2) self.assertSequenceEqual( Identifier.objects.filter(program=None, channel=None), [i3] ) self.assertSequenceEqual( Identifier.objects.exclude(program=None, channel=None).order_by("name"), [i1, i2], ) def test_ticket_21748_double_negated_and(self): i1 = Identifier.objects.create(name="i1") i2 = Identifier.objects.create(name="i2") Identifier.objects.create(name="i3") p1 = Program.objects.create(identifier=i1) c1 = Channel.objects.create(identifier=i1) Program.objects.create(identifier=i2) # Check the ~~Q() (or equivalently .exclude(~Q)) works like Q() for # join promotion. qs1_doubleneg = Identifier.objects.exclude( ~Q(program__id=p1.id, channel__id=c1.id) ).order_by("pk") qs1_filter = Identifier.objects.filter( program__id=p1.id, channel__id=c1.id ).order_by("pk") self.assertQuerysetEqual(qs1_doubleneg, qs1_filter, lambda x: x) self.assertEqual( str(qs1_filter.query).count("JOIN"), str(qs1_doubleneg.query).count("JOIN") ) self.assertEqual(2, str(qs1_doubleneg.query).count("INNER JOIN")) self.assertEqual( str(qs1_filter.query).count("INNER JOIN"), str(qs1_doubleneg.query).count("INNER JOIN"), ) def test_ticket_21748_double_negated_or(self): i1 = Identifier.objects.create(name="i1") i2 = Identifier.objects.create(name="i2") Identifier.objects.create(name="i3") p1 = Program.objects.create(identifier=i1) c1 = Channel.objects.create(identifier=i1) p2 = Program.objects.create(identifier=i2) # Test OR + doubleneg. The expected result is that channel is LOUTER # joined, program INNER joined qs1_filter = Identifier.objects.filter( Q(program__id=p2.id, channel__id=c1.id) | Q(program__id=p1.id) ).order_by("pk") qs1_doubleneg = Identifier.objects.exclude( ~Q(Q(program__id=p2.id, channel__id=c1.id) | Q(program__id=p1.id)) ).order_by("pk") self.assertQuerysetEqual(qs1_doubleneg, qs1_filter, lambda x: x) self.assertEqual( str(qs1_filter.query).count("JOIN"), str(qs1_doubleneg.query).count("JOIN") ) self.assertEqual(1, str(qs1_doubleneg.query).count("INNER JOIN")) self.assertEqual( str(qs1_filter.query).count("INNER JOIN"), str(qs1_doubleneg.query).count("INNER JOIN"), ) def test_ticket_21748_complex_filter(self): i1 = Identifier.objects.create(name="i1") i2 = Identifier.objects.create(name="i2") Identifier.objects.create(name="i3") p1 = Program.objects.create(identifier=i1) c1 = Channel.objects.create(identifier=i1) p2 = Program.objects.create(identifier=i2) # Finally, a more complex case, one time in a way where each # NOT is pushed to lowest level in the boolean tree, and # another query where this isn't done. qs1 = Identifier.objects.filter( ~Q(~Q(program__id=p2.id, channel__id=c1.id) & Q(program__id=p1.id)) ).order_by("pk") qs2 = Identifier.objects.filter( Q(Q(program__id=p2.id, channel__id=c1.id) | ~Q(program__id=p1.id)) ).order_by("pk") self.assertQuerysetEqual(qs1, qs2, lambda x: x) self.assertEqual(str(qs1.query).count("JOIN"), str(qs2.query).count("JOIN")) self.assertEqual(0, str(qs1.query).count("INNER JOIN")) self.assertEqual( str(qs1.query).count("INNER JOIN"), str(qs2.query).count("INNER JOIN") ) class ReverseJoinTrimmingTest(TestCase): def test_reverse_trimming(self): # We don't accidentally trim reverse joins - we can't know if there is # anything on the other side of the join, so trimming reverse joins # can't be done, ever. t = Tag.objects.create() qs = Tag.objects.filter(annotation__tag=t.pk) self.assertIn("INNER JOIN", str(qs.query)) self.assertEqual(list(qs), []) class JoinReuseTest(TestCase): """ The queries reuse joins sensibly (for example, direct joins are always reused). """ def test_fk_reuse(self): qs = Annotation.objects.filter(tag__name="foo").filter(tag__name="bar") self.assertEqual(str(qs.query).count("JOIN"), 1) def test_fk_reuse_select_related(self): qs = Annotation.objects.filter(tag__name="foo").select_related("tag") self.assertEqual(str(qs.query).count("JOIN"), 1) def test_fk_reuse_annotation(self): qs = Annotation.objects.filter(tag__name="foo").annotate(cnt=Count("tag__name")) self.assertEqual(str(qs.query).count("JOIN"), 1) def test_fk_reuse_disjunction(self): qs = Annotation.objects.filter(Q(tag__name="foo") | Q(tag__name="bar")) self.assertEqual(str(qs.query).count("JOIN"), 1) def test_fk_reuse_order_by(self): qs = Annotation.objects.filter(tag__name="foo").order_by("tag__name") self.assertEqual(str(qs.query).count("JOIN"), 1) def test_revo2o_reuse(self): qs = Detail.objects.filter(member__name="foo").filter(member__name="foo") self.assertEqual(str(qs.query).count("JOIN"), 1) def test_revfk_noreuse(self): qs = Author.objects.filter(report__name="r4").filter(report__name="r1") self.assertEqual(str(qs.query).count("JOIN"), 2) def test_inverted_q_across_relations(self): """ When a trimmable join is specified in the query (here school__), the ORM detects it and removes unnecessary joins. The set of reusable joins are updated after trimming the query so that other lookups don't consider that the outer query's filters are in effect for the subquery (#26551). """ springfield_elementary = School.objects.create() hogward = School.objects.create() Student.objects.create(school=springfield_elementary) hp = Student.objects.create(school=hogward) Classroom.objects.create(school=hogward, name="Potion") Classroom.objects.create(school=springfield_elementary, name="Main") qs = Student.objects.filter( ~( Q(school__classroom__name="Main") & Q(school__classroom__has_blackboard=None) ) ) self.assertSequenceEqual(qs, [hp]) class DisjunctionPromotionTests(TestCase): def test_disjunction_promotion_select_related(self): fk1 = FK1.objects.create(f1="f1", f2="f2") basea = BaseA.objects.create(a=fk1) qs = BaseA.objects.filter(Q(a=fk1) | Q(b=2)) self.assertEqual(str(qs.query).count(" JOIN "), 0) qs = qs.select_related("a", "b") self.assertEqual(str(qs.query).count(" INNER JOIN "), 0) self.assertEqual(str(qs.query).count(" LEFT OUTER JOIN "), 2) with self.assertNumQueries(1): self.assertSequenceEqual(qs, [basea]) self.assertEqual(qs[0].a, fk1) self.assertIs(qs[0].b, None) def test_disjunction_promotion1(self): # Pre-existing join, add two ORed filters to the same join, # all joins can be INNER JOINS. qs = BaseA.objects.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) qs = qs.filter(Q(b__f1="foo") | Q(b__f2="foo")) self.assertEqual(str(qs.query).count("INNER JOIN"), 2) # Reverse the order of AND and OR filters. qs = BaseA.objects.filter(Q(b__f1="foo") | Q(b__f2="foo")) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) qs = qs.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 2) def test_disjunction_promotion2(self): qs = BaseA.objects.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) # Now we have two different joins in an ORed condition, these # must be OUTER joins. The pre-existing join should remain INNER. qs = qs.filter(Q(b__f1="foo") | Q(c__f2="foo")) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) # Reverse case. qs = BaseA.objects.filter(Q(b__f1="foo") | Q(c__f2="foo")) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) qs = qs.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) def test_disjunction_promotion3(self): qs = BaseA.objects.filter(a__f2="bar") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) # The ANDed a__f2 filter allows us to use keep using INNER JOIN # even inside the ORed case. If the join to a__ returns nothing, # the ANDed filter for a__f2 can't be true. qs = qs.filter(Q(a__f1="foo") | Q(b__f2="foo")) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) def test_disjunction_promotion3_demote(self): # This one needs demotion logic: the first filter causes a to be # outer joined, the second filter makes it inner join again. qs = BaseA.objects.filter(Q(a__f1="foo") | Q(b__f2="foo")).filter(a__f2="bar") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) def test_disjunction_promotion4_demote(self): qs = BaseA.objects.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("JOIN"), 0) # Demote needed for the "a" join. It is marked as outer join by # above filter (even if it is trimmed away). qs = qs.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) def test_disjunction_promotion4(self): qs = BaseA.objects.filter(a__f1="foo") self.assertEqual(str(qs.query).count("INNER JOIN"), 1) qs = qs.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) def test_disjunction_promotion5_demote(self): qs = BaseA.objects.filter(Q(a=1) | Q(a=2)) # Note that the above filters on a force the join to an # inner join even if it is trimmed. self.assertEqual(str(qs.query).count("JOIN"), 0) qs = qs.filter(Q(a__f1="foo") | Q(b__f1="foo")) # So, now the a__f1 join doesn't need promotion. self.assertEqual(str(qs.query).count("INNER JOIN"), 1) # But b__f1 does. self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) qs = BaseA.objects.filter(Q(a__f1="foo") | Q(b__f1="foo")) # Now the join to a is created as LOUTER self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) qs = qs.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) def test_disjunction_promotion6(self): qs = BaseA.objects.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("JOIN"), 0) qs = BaseA.objects.filter(Q(a__f1="foo") & Q(b__f1="foo")) self.assertEqual(str(qs.query).count("INNER JOIN"), 2) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 0) qs = BaseA.objects.filter(Q(a__f1="foo") & Q(b__f1="foo")) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 0) self.assertEqual(str(qs.query).count("INNER JOIN"), 2) qs = qs.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("INNER JOIN"), 2) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 0) def test_disjunction_promotion7(self): qs = BaseA.objects.filter(Q(a=1) | Q(a=2)) self.assertEqual(str(qs.query).count("JOIN"), 0) qs = BaseA.objects.filter(Q(a__f1="foo") | (Q(b__f1="foo") & Q(a__f1="bar"))) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) qs = BaseA.objects.filter( (Q(a__f1="foo") | Q(b__f1="foo")) & (Q(a__f1="bar") | Q(c__f1="foo")) ) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 3) self.assertEqual(str(qs.query).count("INNER JOIN"), 0) qs = BaseA.objects.filter( Q(a__f1="foo") | Q(a__f1="bar") & (Q(b__f1="bar") | Q(c__f1="foo")) ) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) def test_disjunction_promotion_fexpression(self): qs = BaseA.objects.filter(Q(a__f1=F("b__f1")) | Q(b__f1="foo")) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 1) self.assertEqual(str(qs.query).count("INNER JOIN"), 1) qs = BaseA.objects.filter(Q(a__f1=F("c__f1")) | Q(b__f1="foo")) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 3) qs = BaseA.objects.filter( Q(a__f1=F("b__f1")) | Q(a__f2=F("b__f2")) | Q(c__f1="foo") ) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 3) qs = BaseA.objects.filter(Q(a__f1=F("c__f1")) | (Q(pk=1) & Q(pk=2))) self.assertEqual(str(qs.query).count("LEFT OUTER JOIN"), 2) self.assertEqual(str(qs.query).count("INNER JOIN"), 0) class ManyToManyExcludeTest(TestCase): def test_exclude_many_to_many(self): i_extra = Identifier.objects.create(name="extra") i_program = Identifier.objects.create(name="program") program = Program.objects.create(identifier=i_program) i_channel = Identifier.objects.create(name="channel") channel = Channel.objects.create(identifier=i_channel) channel.programs.add(program) # channel contains 'program1', so all Identifiers except that one # should be returned self.assertSequenceEqual( Identifier.objects.exclude(program__channel=channel).order_by("name"), [i_channel, i_extra], ) self.assertSequenceEqual( Identifier.objects.exclude(program__channel=None).order_by("name"), [i_program], ) def test_ticket_12823(self): pg3 = Page.objects.create(text="pg3") pg2 = Page.objects.create(text="pg2") pg1 = Page.objects.create(text="pg1") pa1 = Paragraph.objects.create(text="pa1") pa1.page.set([pg1, pg2]) pa2 = Paragraph.objects.create(text="pa2") pa2.page.set([pg2, pg3]) pa3 = Paragraph.objects.create(text="pa3") ch1 = Chapter.objects.create(title="ch1", paragraph=pa1) ch2 = Chapter.objects.create(title="ch2", paragraph=pa2) ch3 = Chapter.objects.create(title="ch3", paragraph=pa3) b1 = Book.objects.create(title="b1", chapter=ch1) b2 = Book.objects.create(title="b2", chapter=ch2) b3 = Book.objects.create(title="b3", chapter=ch3) q = Book.objects.exclude(chapter__paragraph__page__text="pg1") self.assertNotIn("IS NOT NULL", str(q.query)) self.assertEqual(len(q), 2) self.assertNotIn(b1, q) self.assertIn(b2, q) self.assertIn(b3, q) class RelabelCloneTest(TestCase): def test_ticket_19964(self): my1 = MyObject.objects.create(data="foo") my1.parent = my1 my1.save() my2 = MyObject.objects.create(data="bar", parent=my1) parents = MyObject.objects.filter(parent=F("id")) children = MyObject.objects.filter(parent__in=parents).exclude(parent=F("id")) self.assertEqual(list(parents), [my1]) # Evaluating the children query (which has parents as part of it) does # not change results for the parents query. self.assertEqual(list(children), [my2]) self.assertEqual(list(parents), [my1]) class Ticket20101Tests(TestCase): def test_ticket_20101(self): """ Tests QuerySet ORed combining in exclude subquery case. """ t = Tag.objects.create(name="foo") a1 = Annotation.objects.create(tag=t, name="a1") a2 = Annotation.objects.create(tag=t, name="a2") a3 = Annotation.objects.create(tag=t, name="a3") n = Note.objects.create(note="foo", misc="bar") qs1 = Note.objects.exclude(annotation__in=[a1, a2]) qs2 = Note.objects.filter(annotation__in=[a3]) self.assertIn(n, qs1) self.assertNotIn(n, qs2) self.assertIn(n, (qs1 | qs2)) class EmptyStringPromotionTests(SimpleTestCase): def test_empty_string_promotion(self): qs = RelatedObject.objects.filter(single__name="") if connection.features.interprets_empty_strings_as_nulls: self.assertIn("LEFT OUTER JOIN", str(qs.query)) else: self.assertNotIn("LEFT OUTER JOIN", str(qs.query)) class ValuesSubqueryTests(TestCase): def test_values_in_subquery(self): # If a values() queryset is used, then the given values # will be used instead of forcing use of the relation's field. o1 = Order.objects.create(id=-2) o2 = Order.objects.create(id=-1) oi1 = OrderItem.objects.create(order=o1, status=0) oi1.status = oi1.pk oi1.save() OrderItem.objects.create(order=o2, status=0) # The query below should match o1 as it has related order_item # with id == status. self.assertSequenceEqual( Order.objects.filter(items__in=OrderItem.objects.values_list("status")), [o1], ) class DoubleInSubqueryTests(TestCase): def test_double_subquery_in(self): lfa1 = LeafA.objects.create(data="foo") lfa2 = LeafA.objects.create(data="bar") lfb1 = LeafB.objects.create(data="lfb1") lfb2 = LeafB.objects.create(data="lfb2") Join.objects.create(a=lfa1, b=lfb1) Join.objects.create(a=lfa2, b=lfb2) leaf_as = LeafA.objects.filter(data="foo").values_list("pk", flat=True) joins = Join.objects.filter(a__in=leaf_as).values_list("b__id", flat=True) qs = LeafB.objects.filter(pk__in=joins) self.assertSequenceEqual(qs, [lfb1]) class Ticket18785Tests(SimpleTestCase): def test_ticket_18785(self): # Test join trimming from ticket18785 qs = ( Item.objects.exclude(note__isnull=False) .filter(name="something", creator__extra__isnull=True) .order_by() ) self.assertEqual(1, str(qs.query).count("INNER JOIN")) self.assertEqual(0, str(qs.query).count("OUTER JOIN")) class Ticket20788Tests(TestCase): def test_ticket_20788(self): Paragraph.objects.create() paragraph = Paragraph.objects.create() page = paragraph.page.create() chapter = Chapter.objects.create(paragraph=paragraph) Book.objects.create(chapter=chapter) paragraph2 = Paragraph.objects.create() Page.objects.create() chapter2 = Chapter.objects.create(paragraph=paragraph2) book2 = Book.objects.create(chapter=chapter2) sentences_not_in_pub = Book.objects.exclude(chapter__paragraph__page=page) self.assertSequenceEqual(sentences_not_in_pub, [book2]) class Ticket12807Tests(TestCase): def test_ticket_12807(self): p1 = Paragraph.objects.create() p2 = Paragraph.objects.create() # The ORed condition below should have no effect on the query - the # ~Q(pk__in=[]) will always be True. qs = Paragraph.objects.filter((Q(pk=p2.pk) | ~Q(pk__in=[])) & Q(pk=p1.pk)) self.assertSequenceEqual(qs, [p1]) class RelatedLookupTypeTests(TestCase): error = 'Cannot query "%s": Must be "%s" instance.' @classmethod def setUpTestData(cls): cls.oa = ObjectA.objects.create(name="oa") cls.poa = ProxyObjectA.objects.get(name="oa") cls.coa = ChildObjectA.objects.create(name="coa") cls.wrong_type = Order.objects.create(id=cls.oa.pk) cls.ob = ObjectB.objects.create(name="ob", objecta=cls.oa, num=1) cls.pob1 = ProxyObjectB.objects.create(name="pob", objecta=cls.oa, num=2) cls.pob = ProxyObjectB.objects.all() cls.c = ObjectC.objects.create(childobjecta=cls.coa) def test_wrong_type_lookup(self): """ A ValueError is raised when the incorrect object type is passed to a query lookup. """ # Passing incorrect object type with self.assertRaisesMessage( ValueError, self.error % (self.wrong_type, ObjectA._meta.object_name) ): ObjectB.objects.get(objecta=self.wrong_type) with self.assertRaisesMessage( ValueError, self.error % (self.wrong_type, ObjectA._meta.object_name) ): ObjectB.objects.filter(objecta__in=[self.wrong_type]) with self.assertRaisesMessage( ValueError, self.error % (self.wrong_type, ObjectA._meta.object_name) ): ObjectB.objects.filter(objecta=self.wrong_type) with self.assertRaisesMessage( ValueError, self.error % (self.wrong_type, ObjectB._meta.object_name) ): ObjectA.objects.filter(objectb__in=[self.wrong_type, self.ob]) # Passing an object of the class on which query is done. with self.assertRaisesMessage( ValueError, self.error % (self.ob, ObjectA._meta.object_name) ): ObjectB.objects.filter(objecta__in=[self.poa, self.ob]) with self.assertRaisesMessage( ValueError, self.error % (self.ob, ChildObjectA._meta.object_name) ): ObjectC.objects.exclude(childobjecta__in=[self.coa, self.ob]) def test_wrong_backward_lookup(self): """ A ValueError is raised when the incorrect object type is passed to a query lookup for backward relations. """ with self.assertRaisesMessage( ValueError, self.error % (self.oa, ObjectB._meta.object_name) ): ObjectA.objects.filter(objectb__in=[self.oa, self.ob]) with self.assertRaisesMessage( ValueError, self.error % (self.oa, ObjectB._meta.object_name) ): ObjectA.objects.exclude(objectb=self.oa) with self.assertRaisesMessage( ValueError, self.error % (self.wrong_type, ObjectB._meta.object_name) ): ObjectA.objects.get(objectb=self.wrong_type) def test_correct_lookup(self): """ When passing proxy model objects, child objects, or parent objects, lookups work fine. """ out_a = [self.oa] out_b = [self.ob, self.pob1] out_c = [self.c] # proxy model objects self.assertSequenceEqual( ObjectB.objects.filter(objecta=self.poa).order_by("name"), out_b ) self.assertSequenceEqual( ObjectA.objects.filter(objectb__in=self.pob).order_by("pk"), out_a * 2 ) # child objects self.assertSequenceEqual(ObjectB.objects.filter(objecta__in=[self.coa]), []) self.assertSequenceEqual( ObjectB.objects.filter(objecta__in=[self.poa, self.coa]).order_by("name"), out_b, ) self.assertSequenceEqual( ObjectB.objects.filter(objecta__in=iter([self.poa, self.coa])).order_by( "name" ), out_b, ) # parent objects self.assertSequenceEqual(ObjectC.objects.exclude(childobjecta=self.oa), out_c) # QuerySet related object type checking shouldn't issue queries # (the querysets aren't evaluated here, hence zero queries) (#23266). with self.assertNumQueries(0): ObjectB.objects.filter(objecta__in=ObjectA.objects.all()) def test_values_queryset_lookup(self): """ ValueQuerySets are not checked for compatibility with the lookup field. """ # Make sure the num and objecta field values match. ob = ObjectB.objects.get(name="ob") ob.num = ob.objecta.pk ob.save() pob = ObjectB.objects.get(name="pob") pob.num = pob.objecta.pk pob.save() self.assertSequenceEqual( ObjectB.objects.filter( objecta__in=ObjectB.objects.values_list("num") ).order_by("pk"), [ob, pob], ) class Ticket14056Tests(TestCase): def test_ticket_14056(self): s1 = SharedConnection.objects.create(data="s1") s2 = SharedConnection.objects.create(data="s2") s3 = SharedConnection.objects.create(data="s3") PointerA.objects.create(connection=s2) expected_ordering = ( [s1, s3, s2] if connection.features.nulls_order_largest else [s2, s1, s3] ) self.assertSequenceEqual( SharedConnection.objects.order_by("-pointera__connection", "pk"), expected_ordering, ) class Ticket20955Tests(TestCase): def test_ticket_20955(self): jack = Staff.objects.create(name="jackstaff") jackstaff = StaffUser.objects.create(staff=jack) jill = Staff.objects.create(name="jillstaff") jillstaff = StaffUser.objects.create(staff=jill) task = Task.objects.create(creator=jackstaff, owner=jillstaff, title="task") task_get = Task.objects.get(pk=task.pk) # Load data so that assertNumQueries doesn't complain about the get # version's queries. task_get.creator.staffuser.staff task_get.owner.staffuser.staff qs = Task.objects.select_related( "creator__staffuser__staff", "owner__staffuser__staff" ) self.assertEqual(str(qs.query).count(" JOIN "), 6) task_select_related = qs.get(pk=task.pk) with self.assertNumQueries(0): self.assertEqual( task_select_related.creator.staffuser.staff, task_get.creator.staffuser.staff, ) self.assertEqual( task_select_related.owner.staffuser.staff, task_get.owner.staffuser.staff, ) class Ticket21203Tests(TestCase): def test_ticket_21203(self): p = Ticket21203Parent.objects.create(parent_bool=True) c = Ticket21203Child.objects.create(parent=p) qs = Ticket21203Child.objects.select_related("parent").defer("parent__created") self.assertSequenceEqual(qs, [c]) self.assertIs(qs[0].parent.parent_bool, True) class ValuesJoinPromotionTests(TestCase): def test_values_no_promotion_for_existing(self): qs = Node.objects.filter(parent__parent__isnull=False) self.assertIn(" INNER JOIN ", str(qs.query)) qs = qs.values("parent__parent__id") self.assertIn(" INNER JOIN ", str(qs.query)) # Make sure there is a left outer join without the filter. qs = Node.objects.values("parent__parent__id") self.assertIn(" LEFT OUTER JOIN ", str(qs.query)) def test_non_nullable_fk_not_promoted(self): qs = ObjectB.objects.values("objecta__name") self.assertIn(" INNER JOIN ", str(qs.query)) def test_ticket_21376(self): a = ObjectA.objects.create() ObjectC.objects.create(objecta=a) qs = ObjectC.objects.filter( Q(objecta=a) | Q(objectb__objecta=a), ) qs = qs.filter( Q(objectb=1) | Q(objecta=a), ) self.assertEqual(qs.count(), 1) tblname = connection.ops.quote_name(ObjectB._meta.db_table) self.assertIn(" LEFT OUTER JOIN %s" % tblname, str(qs.query)) class ForeignKeyToBaseExcludeTests(TestCase): def test_ticket_21787(self): sc1 = SpecialCategory.objects.create(special_name="sc1", name="sc1") sc2 = SpecialCategory.objects.create(special_name="sc2", name="sc2") sc3 = SpecialCategory.objects.create(special_name="sc3", name="sc3") c1 = CategoryItem.objects.create(category=sc1) CategoryItem.objects.create(category=sc2) self.assertSequenceEqual( SpecialCategory.objects.exclude(categoryitem__id=c1.pk).order_by("name"), [sc2, sc3], ) self.assertSequenceEqual( SpecialCategory.objects.filter(categoryitem__id=c1.pk), [sc1] ) class ReverseM2MCustomPkTests(TestCase): def test_ticket_21879(self): cpt1 = CustomPkTag.objects.create(id="cpt1", tag="cpt1") cp1 = CustomPk.objects.create(name="cp1", extra="extra") cp1.custompktag_set.add(cpt1) self.assertSequenceEqual(CustomPk.objects.filter(custompktag=cpt1), [cp1]) self.assertSequenceEqual(CustomPkTag.objects.filter(custom_pk=cp1), [cpt1]) class Ticket22429Tests(TestCase): def test_ticket_22429(self): sc1 = School.objects.create() st1 = Student.objects.create(school=sc1) sc2 = School.objects.create() st2 = Student.objects.create(school=sc2) cr = Classroom.objects.create(school=sc1) cr.students.add(st1) queryset = Student.objects.filter(~Q(classroom__school=F("school"))) self.assertSequenceEqual(queryset, [st2]) class Ticket23605Tests(TestCase): def test_ticket_23605(self): # Test filtering on a complicated q-object from ticket's report. # The query structure is such that we have multiple nested subqueries. # The original problem was that the inner queries weren't relabeled # correctly. # See also #24090. a1 = Ticket23605A.objects.create() a2 = Ticket23605A.objects.create() c1 = Ticket23605C.objects.create(field_c0=10000.0) Ticket23605B.objects.create( field_b0=10000.0, field_b1=True, modelc_fk=c1, modela_fk=a1 ) complex_q = Q( pk__in=Ticket23605A.objects.filter( Q( # True for a1 as field_b0 = 10000, field_c0=10000 # False for a2 as no ticket23605b found ticket23605b__field_b0__gte=1000000 / F("ticket23605b__modelc_fk__field_c0") ) & # True for a1 (field_b1=True) Q(ticket23605b__field_b1=True) & ~Q( ticket23605b__pk__in=Ticket23605B.objects.filter( ~( # Same filters as above commented filters, but # double-negated (one for Q() above, one for # parentheses). So, again a1 match, a2 not. Q(field_b1=True) & Q(field_b0__gte=1000000 / F("modelc_fk__field_c0")) ) ) ) ).filter(ticket23605b__field_b1=True) ) qs1 = Ticket23605A.objects.filter(complex_q) self.assertSequenceEqual(qs1, [a1]) qs2 = Ticket23605A.objects.exclude(complex_q) self.assertSequenceEqual(qs2, [a2]) class TestTicket24279(TestCase): def test_ticket_24278(self): School.objects.create() qs = School.objects.filter(Q(pk__in=()) | Q()) self.assertQuerysetEqual(qs, []) class TestInvalidValuesRelation(SimpleTestCase): def test_invalid_values(self): msg = "Field 'id' expected a number but got 'abc'." with self.assertRaisesMessage(ValueError, msg): Annotation.objects.filter(tag="abc") with self.assertRaisesMessage(ValueError, msg): Annotation.objects.filter(tag__in=[123, "abc"]) class TestTicket24605(TestCase): def test_ticket_24605(self): """ Subquery table names should be quoted. """ i1 = Individual.objects.create(alive=True) RelatedIndividual.objects.create(related=i1) i2 = Individual.objects.create(alive=False) RelatedIndividual.objects.create(related=i2) i3 = Individual.objects.create(alive=True) i4 = Individual.objects.create(alive=False) self.assertSequenceEqual( Individual.objects.filter( Q(alive=False), Q(related_individual__isnull=True) ), [i4], ) self.assertSequenceEqual( Individual.objects.exclude( Q(alive=False), Q(related_individual__isnull=True) ).order_by("pk"), [i1, i2, i3], ) class Ticket23622Tests(TestCase): @skipUnlessDBFeature("can_distinct_on_fields") def test_ticket_23622(self): """ Make sure __pk__in and __in work the same for related fields when using a distinct on subquery. """ a1 = Ticket23605A.objects.create() a2 = Ticket23605A.objects.create() c1 = Ticket23605C.objects.create(field_c0=0.0) Ticket23605B.objects.create( modela_fk=a1, field_b0=123, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a1, field_b0=23, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a1, field_b0=234, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a1, field_b0=12, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a2, field_b0=567, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a2, field_b0=76, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a2, field_b0=7, field_b1=True, modelc_fk=c1, ) Ticket23605B.objects.create( modela_fk=a2, field_b0=56, field_b1=True, modelc_fk=c1, ) qx = Q( ticket23605b__pk__in=Ticket23605B.objects.order_by( "modela_fk", "-field_b1" ).distinct("modela_fk") ) & Q(ticket23605b__field_b0__gte=300) qy = Q( ticket23605b__in=Ticket23605B.objects.order_by( "modela_fk", "-field_b1" ).distinct("modela_fk") ) & Q(ticket23605b__field_b0__gte=300) self.assertEqual( set(Ticket23605A.objects.filter(qx).values_list("pk", flat=True)), set(Ticket23605A.objects.filter(qy).values_list("pk", flat=True)), ) self.assertSequenceEqual(Ticket23605A.objects.filter(qx), [a2])
a617ce328195fb060a3420ce030fd3069d8d3e7be58a96cce01a7bfa17972bf1
""" Various complex queries that have been problematic in the past. """ from django.db import models from django.db.models.functions import Now class DumbCategory(models.Model): pass class ProxyCategory(DumbCategory): class Meta: proxy = True class NamedCategory(DumbCategory): name = models.CharField(max_length=10) def __str__(self): return self.name class Tag(models.Model): name = models.CharField(max_length=10) parent = models.ForeignKey( "self", models.SET_NULL, blank=True, null=True, related_name="children", ) category = models.ForeignKey( NamedCategory, models.SET_NULL, null=True, default=None ) class Meta: ordering = ["name"] def __str__(self): return self.name class Note(models.Model): note = models.CharField(max_length=100) misc = models.CharField(max_length=25) tag = models.ForeignKey(Tag, models.SET_NULL, blank=True, null=True) negate = models.BooleanField(default=True) class Meta: ordering = ["note"] def __str__(self): return self.note class Annotation(models.Model): name = models.CharField(max_length=10) tag = models.ForeignKey(Tag, models.CASCADE) notes = models.ManyToManyField(Note) def __str__(self): return self.name class DateTimePK(models.Model): date = models.DateTimeField(primary_key=True, auto_now_add=True) class ExtraInfo(models.Model): info = models.CharField(max_length=100) note = models.ForeignKey(Note, models.CASCADE, null=True) value = models.IntegerField(null=True) date = models.ForeignKey(DateTimePK, models.SET_NULL, null=True) filterable = models.BooleanField(default=True) class Meta: ordering = ["info"] def __str__(self): return self.info class Author(models.Model): name = models.CharField(max_length=10) num = models.IntegerField(unique=True) extra = models.ForeignKey(ExtraInfo, models.CASCADE) class Meta: ordering = ["name"] def __str__(self): return self.name class Item(models.Model): name = models.CharField(max_length=10) created = models.DateTimeField() modified = models.DateTimeField(blank=True, null=True) tags = models.ManyToManyField(Tag, blank=True) creator = models.ForeignKey(Author, models.CASCADE) note = models.ForeignKey(Note, models.CASCADE) class Meta: ordering = ["-note", "name"] def __str__(self): return self.name class Report(models.Model): name = models.CharField(max_length=10) creator = models.ForeignKey(Author, models.SET_NULL, to_field="num", null=True) def __str__(self): return self.name class ReportComment(models.Model): report = models.ForeignKey(Report, models.CASCADE) class Ranking(models.Model): rank = models.IntegerField() author = models.ForeignKey(Author, models.CASCADE) class Meta: # A complex ordering specification. Should stress the system a bit. ordering = ("author__extra__note", "author__name", "rank") def __str__(self): return "%d: %s" % (self.rank, self.author.name) class Cover(models.Model): title = models.CharField(max_length=50) item = models.ForeignKey(Item, models.CASCADE) class Meta: ordering = ["item"] def __str__(self): return self.title class Number(models.Model): num = models.IntegerField() other_num = models.IntegerField(null=True) another_num = models.IntegerField(null=True) def __str__(self): return str(self.num) # Symmetrical m2m field with a normal field using the reverse accessor name # ("valid"). class Valid(models.Model): valid = models.CharField(max_length=10) parent = models.ManyToManyField("self") class Meta: ordering = ["valid"] # Some funky cross-linked models for testing a couple of infinite recursion # cases. class X(models.Model): y = models.ForeignKey("Y", models.CASCADE) class Y(models.Model): x1 = models.ForeignKey(X, models.CASCADE, related_name="y1") # Some models with a cycle in the default ordering. This would be bad if we # didn't catch the infinite loop. class LoopX(models.Model): y = models.ForeignKey("LoopY", models.CASCADE) class Meta: ordering = ["y"] class LoopY(models.Model): x = models.ForeignKey(LoopX, models.CASCADE) class Meta: ordering = ["x"] class LoopZ(models.Model): z = models.ForeignKey("self", models.CASCADE) class Meta: ordering = ["z"] # A model and custom default manager combination. class CustomManager(models.Manager): def get_queryset(self): qs = super().get_queryset() return qs.filter(public=True, tag__name="t1") class ManagedModel(models.Model): data = models.CharField(max_length=10) tag = models.ForeignKey(Tag, models.CASCADE) public = models.BooleanField(default=True) objects = CustomManager() normal_manager = models.Manager() def __str__(self): return self.data # An inter-related setup with multiple paths from Child to Detail. class Detail(models.Model): data = models.CharField(max_length=10) class MemberManager(models.Manager): def get_queryset(self): return super().get_queryset().select_related("details") class Member(models.Model): name = models.CharField(max_length=10) details = models.OneToOneField(Detail, models.CASCADE, primary_key=True) objects = MemberManager() class Child(models.Model): person = models.OneToOneField(Member, models.CASCADE, primary_key=True) parent = models.ForeignKey(Member, models.CASCADE, related_name="children") # Custom primary keys interfered with ordering in the past. class CustomPk(models.Model): name = models.CharField(max_length=10, primary_key=True) extra = models.CharField(max_length=10) class Meta: ordering = ["name", "extra"] class Related(models.Model): custom = models.ForeignKey(CustomPk, models.CASCADE, null=True) class CustomPkTag(models.Model): id = models.CharField(max_length=20, primary_key=True) custom_pk = models.ManyToManyField(CustomPk) tag = models.CharField(max_length=20) # An inter-related setup with a model subclass that has a nullable # path to another model, and a return path from that model. class Celebrity(models.Model): name = models.CharField("Name", max_length=20) greatest_fan = models.ForeignKey("Fan", models.SET_NULL, null=True, unique=True) def __str__(self): return self.name class TvChef(Celebrity): pass class Fan(models.Model): fan_of = models.ForeignKey(Celebrity, models.CASCADE) # Multiple foreign keys class LeafA(models.Model): data = models.CharField(max_length=10) def __str__(self): return self.data class LeafB(models.Model): data = models.CharField(max_length=10) class Join(models.Model): a = models.ForeignKey(LeafA, models.CASCADE) b = models.ForeignKey(LeafB, models.CASCADE) class ReservedName(models.Model): name = models.CharField(max_length=20) order = models.IntegerField() def __str__(self): return self.name # A simpler shared-foreign-key setup that can expose some problems. class SharedConnection(models.Model): data = models.CharField(max_length=10) def __str__(self): return self.data class PointerA(models.Model): connection = models.ForeignKey(SharedConnection, models.CASCADE) class PointerB(models.Model): connection = models.ForeignKey(SharedConnection, models.CASCADE) # Multi-layer ordering class SingleObject(models.Model): name = models.CharField(max_length=10) class Meta: ordering = ["name"] def __str__(self): return self.name class RelatedObject(models.Model): single = models.ForeignKey(SingleObject, models.SET_NULL, null=True) f = models.IntegerField(null=True) class Meta: ordering = ["single"] class Plaything(models.Model): name = models.CharField(max_length=10) others = models.ForeignKey(RelatedObject, models.SET_NULL, null=True) class Meta: ordering = ["others"] def __str__(self): return self.name class Article(models.Model): name = models.CharField(max_length=20) created = models.DateTimeField() def __str__(self): return self.name class Food(models.Model): name = models.CharField(max_length=20, unique=True) def __str__(self): return self.name class Eaten(models.Model): food = models.ForeignKey(Food, models.SET_NULL, to_field="name", null=True) meal = models.CharField(max_length=20) def __str__(self): return "%s at %s" % (self.food, self.meal) class Node(models.Model): num = models.IntegerField(unique=True) parent = models.ForeignKey("self", models.SET_NULL, to_field="num", null=True) def __str__(self): return str(self.num) # Bug #12252 class ObjectA(models.Model): name = models.CharField(max_length=50) def __str__(self): return self.name def __iter__(self): # Ticket #23721 assert False, "type checking should happen without calling model __iter__" class ProxyObjectA(ObjectA): class Meta: proxy = True class ChildObjectA(ObjectA): pass class ObjectB(models.Model): name = models.CharField(max_length=50) objecta = models.ForeignKey(ObjectA, models.CASCADE) num = models.PositiveIntegerField() def __str__(self): return self.name class ProxyObjectB(ObjectB): class Meta: proxy = True class ObjectC(models.Model): name = models.CharField(max_length=50) objecta = models.ForeignKey(ObjectA, models.SET_NULL, null=True) objectb = models.ForeignKey(ObjectB, models.SET_NULL, null=True) childobjecta = models.ForeignKey( ChildObjectA, models.SET_NULL, null=True, related_name="ca_pk" ) def __str__(self): return self.name class SimpleCategory(models.Model): name = models.CharField(max_length=25) def __str__(self): return self.name class SpecialCategory(SimpleCategory): special_name = models.CharField(max_length=35) def __str__(self): return self.name + " " + self.special_name class CategoryItem(models.Model): category = models.ForeignKey(SimpleCategory, models.CASCADE) def __str__(self): return "category item: " + str(self.category) class MixedCaseFieldCategoryItem(models.Model): CaTeGoRy = models.ForeignKey(SimpleCategory, models.CASCADE) class MixedCaseDbColumnCategoryItem(models.Model): category = models.ForeignKey( SimpleCategory, models.CASCADE, db_column="CaTeGoRy_Id" ) class OneToOneCategory(models.Model): new_name = models.CharField(max_length=15) category = models.OneToOneField(SimpleCategory, models.CASCADE) def __str__(self): return "one2one " + self.new_name class CategoryRelationship(models.Model): first = models.ForeignKey(SimpleCategory, models.CASCADE, related_name="first_rel") second = models.ForeignKey( SimpleCategory, models.CASCADE, related_name="second_rel" ) class CommonMixedCaseForeignKeys(models.Model): category = models.ForeignKey(CategoryItem, models.CASCADE) mixed_case_field_category = models.ForeignKey( MixedCaseFieldCategoryItem, models.CASCADE ) mixed_case_db_column_category = models.ForeignKey( MixedCaseDbColumnCategoryItem, models.CASCADE ) class NullableName(models.Model): name = models.CharField(max_length=20, null=True) class Meta: ordering = ["id"] class ModelD(models.Model): name = models.TextField() class ModelC(models.Model): name = models.TextField() class ModelB(models.Model): name = models.TextField() c = models.ForeignKey(ModelC, models.CASCADE) class ModelA(models.Model): name = models.TextField() b = models.ForeignKey(ModelB, models.SET_NULL, null=True) d = models.ForeignKey(ModelD, models.CASCADE) class Job(models.Model): name = models.CharField(max_length=20, unique=True) def __str__(self): return self.name class JobResponsibilities(models.Model): job = models.ForeignKey(Job, models.CASCADE, to_field="name") responsibility = models.ForeignKey( "Responsibility", models.CASCADE, to_field="description" ) class Responsibility(models.Model): description = models.CharField(max_length=20, unique=True) jobs = models.ManyToManyField( Job, through=JobResponsibilities, related_name="responsibilities" ) def __str__(self): return self.description # Models for disjunction join promotion low level testing. class FK1(models.Model): f1 = models.TextField() f2 = models.TextField() class FK2(models.Model): f1 = models.TextField() f2 = models.TextField() class FK3(models.Model): f1 = models.TextField() f2 = models.TextField() class BaseA(models.Model): a = models.ForeignKey(FK1, models.SET_NULL, null=True) b = models.ForeignKey(FK2, models.SET_NULL, null=True) c = models.ForeignKey(FK3, models.SET_NULL, null=True) class Identifier(models.Model): name = models.CharField(max_length=100) def __str__(self): return self.name class Program(models.Model): identifier = models.OneToOneField(Identifier, models.CASCADE) class Channel(models.Model): programs = models.ManyToManyField(Program) identifier = models.OneToOneField(Identifier, models.CASCADE) class Book(models.Model): title = models.TextField() chapter = models.ForeignKey("Chapter", models.CASCADE) class Chapter(models.Model): title = models.TextField() paragraph = models.ForeignKey("Paragraph", models.CASCADE) class Paragraph(models.Model): text = models.TextField() page = models.ManyToManyField("Page") class Page(models.Model): text = models.TextField() class MyObject(models.Model): parent = models.ForeignKey( "self", models.SET_NULL, null=True, blank=True, related_name="children" ) data = models.CharField(max_length=100) created_at = models.DateTimeField(auto_now_add=True) # Models for #17600 regressions class Order(models.Model): id = models.IntegerField(primary_key=True) name = models.CharField(max_length=12, null=True, default="") class Meta: ordering = ("pk",) def __str__(self): return str(self.pk) class OrderItem(models.Model): order = models.ForeignKey(Order, models.CASCADE, related_name="items") status = models.IntegerField() class Meta: ordering = ("pk",) def __str__(self): return str(self.pk) class BaseUser(models.Model): annotation = models.ForeignKey(Annotation, models.CASCADE, null=True, blank=True) class Task(models.Model): title = models.CharField(max_length=10) owner = models.ForeignKey(BaseUser, models.CASCADE, related_name="owner") creator = models.ForeignKey(BaseUser, models.CASCADE, related_name="creator") note = models.ForeignKey(Note, on_delete=models.CASCADE, null=True, blank=True) def __str__(self): return self.title class Staff(models.Model): name = models.CharField(max_length=10) def __str__(self): return self.name class StaffUser(BaseUser): staff = models.OneToOneField(Staff, models.CASCADE, related_name="user") def __str__(self): return str(self.staff) class Ticket21203Parent(models.Model): parentid = models.AutoField(primary_key=True) parent_bool = models.BooleanField(default=True) created = models.DateTimeField(auto_now=True) class Ticket21203Child(models.Model): childid = models.AutoField(primary_key=True) parent = models.ForeignKey(Ticket21203Parent, models.CASCADE) class Person(models.Model): name = models.CharField(max_length=128) class Company(models.Model): name = models.CharField(max_length=128) employees = models.ManyToManyField( Person, related_name="employers", through="Employment" ) def __str__(self): return self.name class Employment(models.Model): employer = models.ForeignKey(Company, models.CASCADE) employee = models.ForeignKey(Person, models.CASCADE) title = models.CharField(max_length=128) class School(models.Model): pass class Student(models.Model): school = models.ForeignKey(School, models.CASCADE) class Classroom(models.Model): name = models.CharField(max_length=20) has_blackboard = models.BooleanField(null=True) school = models.ForeignKey(School, models.CASCADE) students = models.ManyToManyField(Student, related_name="classroom") class Teacher(models.Model): schools = models.ManyToManyField(School) friends = models.ManyToManyField("self") class Ticket23605AParent(models.Model): pass class Ticket23605A(Ticket23605AParent): pass class Ticket23605B(models.Model): modela_fk = models.ForeignKey(Ticket23605A, models.CASCADE) modelc_fk = models.ForeignKey("Ticket23605C", models.CASCADE) field_b0 = models.IntegerField(null=True) field_b1 = models.BooleanField(default=False) class Ticket23605C(models.Model): field_c0 = models.FloatField() # db_table names have capital letters to ensure they are quoted in queries. class Individual(models.Model): alive = models.BooleanField() class Meta: db_table = "Individual" class RelatedIndividual(models.Model): related = models.ForeignKey( Individual, models.CASCADE, related_name="related_individual" ) class Meta: db_table = "RelatedIndividual" class CustomDbColumn(models.Model): custom_column = models.IntegerField(db_column="custom_name", null=True) ip_address = models.GenericIPAddressField(null=True) class CreatedField(models.DateTimeField): db_returning = True def __init__(self, *args, **kwargs): kwargs.setdefault("default", Now) super().__init__(*args, **kwargs) class ReturningModel(models.Model): created = CreatedField(editable=False) class NonIntegerPKReturningModel(models.Model): created = CreatedField(editable=False, primary_key=True) class JSONFieldNullable(models.Model): json_field = models.JSONField(blank=True, null=True) class Meta: required_db_features = {"supports_json_field"}
2fa783bf0365235b0e851cb2bd5c50dab117d373ce58999ba417cef1d5f4b148
import operator from django.db import DatabaseError, NotSupportedError, connection from django.db.models import Exists, F, IntegerField, OuterRef, Subquery, Value from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature from django.test.utils import CaptureQueriesContext from .models import Author, Celebrity, ExtraInfo, Number, ReservedName @skipUnlessDBFeature("supports_select_union") class QuerySetSetOperationTests(TestCase): @classmethod def setUpTestData(cls): Number.objects.bulk_create(Number(num=i, other_num=10 - i) for i in range(10)) def assertNumbersEqual(self, queryset, expected_numbers, ordered=True): self.assertQuerysetEqual( queryset, expected_numbers, operator.attrgetter("num"), ordered ) def test_simple_union(self): qs1 = Number.objects.filter(num__lte=1) qs2 = Number.objects.filter(num__gte=8) qs3 = Number.objects.filter(num=5) self.assertNumbersEqual(qs1.union(qs2, qs3), [0, 1, 5, 8, 9], ordered=False) @skipUnlessDBFeature("supports_select_intersection") def test_simple_intersection(self): qs1 = Number.objects.filter(num__lte=5) qs2 = Number.objects.filter(num__gte=5) qs3 = Number.objects.filter(num__gte=4, num__lte=6) self.assertNumbersEqual(qs1.intersection(qs2, qs3), [5], ordered=False) @skipUnlessDBFeature("supports_select_intersection") def test_intersection_with_values(self): ReservedName.objects.create(name="a", order=2) qs1 = ReservedName.objects.all() reserved_name = qs1.intersection(qs1).values("name", "order", "id").get() self.assertEqual(reserved_name["name"], "a") self.assertEqual(reserved_name["order"], 2) reserved_name = qs1.intersection(qs1).values_list("name", "order", "id").get() self.assertEqual(reserved_name[:2], ("a", 2)) @skipUnlessDBFeature("supports_select_difference") def test_simple_difference(self): qs1 = Number.objects.filter(num__lte=5) qs2 = Number.objects.filter(num__lte=4) self.assertNumbersEqual(qs1.difference(qs2), [5], ordered=False) def test_union_distinct(self): qs1 = Number.objects.all() qs2 = Number.objects.all() self.assertEqual(len(list(qs1.union(qs2, all=True))), 20) self.assertEqual(len(list(qs1.union(qs2))), 10) def test_union_none(self): qs1 = Number.objects.filter(num__lte=1) qs2 = Number.objects.filter(num__gte=8) qs3 = qs1.union(qs2) self.assertSequenceEqual(qs3.none(), []) self.assertNumbersEqual(qs3, [0, 1, 8, 9], ordered=False) @skipUnlessDBFeature("supports_select_intersection") def test_intersection_with_empty_qs(self): qs1 = Number.objects.all() qs2 = Number.objects.none() qs3 = Number.objects.filter(pk__in=[]) self.assertEqual(len(qs1.intersection(qs2)), 0) self.assertEqual(len(qs1.intersection(qs3)), 0) self.assertEqual(len(qs2.intersection(qs1)), 0) self.assertEqual(len(qs3.intersection(qs1)), 0) self.assertEqual(len(qs2.intersection(qs2)), 0) self.assertEqual(len(qs3.intersection(qs3)), 0) @skipUnlessDBFeature("supports_select_difference") def test_difference_with_empty_qs(self): qs1 = Number.objects.all() qs2 = Number.objects.none() qs3 = Number.objects.filter(pk__in=[]) self.assertEqual(len(qs1.difference(qs2)), 10) self.assertEqual(len(qs1.difference(qs3)), 10) self.assertEqual(len(qs2.difference(qs1)), 0) self.assertEqual(len(qs3.difference(qs1)), 0) self.assertEqual(len(qs2.difference(qs2)), 0) self.assertEqual(len(qs3.difference(qs3)), 0) @skipUnlessDBFeature("supports_select_difference") def test_difference_with_values(self): ReservedName.objects.create(name="a", order=2) qs1 = ReservedName.objects.all() qs2 = ReservedName.objects.none() reserved_name = qs1.difference(qs2).values("name", "order", "id").get() self.assertEqual(reserved_name["name"], "a") self.assertEqual(reserved_name["order"], 2) reserved_name = qs1.difference(qs2).values_list("name", "order", "id").get() self.assertEqual(reserved_name[:2], ("a", 2)) def test_union_with_empty_qs(self): qs1 = Number.objects.all() qs2 = Number.objects.none() qs3 = Number.objects.filter(pk__in=[]) self.assertEqual(len(qs1.union(qs2)), 10) self.assertEqual(len(qs2.union(qs1)), 10) self.assertEqual(len(qs1.union(qs3)), 10) self.assertEqual(len(qs3.union(qs1)), 10) self.assertEqual(len(qs2.union(qs1, qs1, qs1)), 10) self.assertEqual(len(qs2.union(qs1, qs1, all=True)), 20) self.assertEqual(len(qs2.union(qs2)), 0) self.assertEqual(len(qs3.union(qs3)), 0) def test_empty_qs_union_with_ordered_qs(self): qs1 = Number.objects.order_by("num") qs2 = Number.objects.none().union(qs1).order_by("num") self.assertEqual(list(qs1), list(qs2)) def test_limits(self): qs1 = Number.objects.all() qs2 = Number.objects.all() self.assertEqual(len(list(qs1.union(qs2)[:2])), 2) def test_ordering(self): qs1 = Number.objects.filter(num__lte=1) qs2 = Number.objects.filter(num__gte=2, num__lte=3) self.assertNumbersEqual(qs1.union(qs2).order_by("-num"), [3, 2, 1, 0]) def test_ordering_by_alias(self): qs1 = Number.objects.filter(num__lte=1).values(alias=F("num")) qs2 = Number.objects.filter(num__gte=2, num__lte=3).values(alias=F("num")) self.assertQuerysetEqual( qs1.union(qs2).order_by("-alias"), [3, 2, 1, 0], operator.itemgetter("alias"), ) def test_ordering_by_f_expression(self): qs1 = Number.objects.filter(num__lte=1) qs2 = Number.objects.filter(num__gte=2, num__lte=3) self.assertNumbersEqual(qs1.union(qs2).order_by(F("num").desc()), [3, 2, 1, 0]) def test_ordering_by_f_expression_and_alias(self): qs1 = Number.objects.filter(num__lte=1).values(alias=F("other_num")) qs2 = Number.objects.filter(num__gte=2, num__lte=3).values(alias=F("other_num")) self.assertQuerysetEqual( qs1.union(qs2).order_by(F("alias").desc()), [10, 9, 8, 7], operator.itemgetter("alias"), ) Number.objects.create(num=-1) self.assertQuerysetEqual( qs1.union(qs2).order_by(F("alias").desc(nulls_last=True)), [10, 9, 8, 7, None], operator.itemgetter("alias"), ) def test_union_with_values(self): ReservedName.objects.create(name="a", order=2) qs1 = ReservedName.objects.all() reserved_name = qs1.union(qs1).values("name", "order", "id").get() self.assertEqual(reserved_name["name"], "a") self.assertEqual(reserved_name["order"], 2) reserved_name = qs1.union(qs1).values_list("name", "order", "id").get() self.assertEqual(reserved_name[:2], ("a", 2)) # List of columns can be changed. reserved_name = qs1.union(qs1).values_list("order").get() self.assertEqual(reserved_name, (2,)) def test_union_with_two_annotated_values_list(self): qs1 = ( Number.objects.filter(num=1) .annotate( count=Value(0, IntegerField()), ) .values_list("num", "count") ) qs2 = ( Number.objects.filter(num=2) .values("pk") .annotate( count=F("num"), ) .annotate( num=Value(1, IntegerField()), ) .values_list("num", "count") ) self.assertCountEqual(qs1.union(qs2), [(1, 0), (2, 1)]) def test_union_with_extra_and_values_list(self): qs1 = ( Number.objects.filter(num=1) .extra( select={"count": 0}, ) .values_list("num", "count") ) qs2 = Number.objects.filter(num=2).extra(select={"count": 1}) self.assertCountEqual(qs1.union(qs2), [(1, 0), (2, 1)]) def test_union_with_values_list_on_annotated_and_unannotated(self): ReservedName.objects.create(name="rn1", order=1) qs1 = Number.objects.annotate( has_reserved_name=Exists(ReservedName.objects.filter(order=OuterRef("num"))) ).filter(has_reserved_name=True) qs2 = Number.objects.filter(num=9) self.assertCountEqual(qs1.union(qs2).values_list("num", flat=True), [1, 9]) def test_union_with_values_list_and_order(self): ReservedName.objects.bulk_create( [ ReservedName(name="rn1", order=7), ReservedName(name="rn2", order=5), ReservedName(name="rn0", order=6), ReservedName(name="rn9", order=-1), ] ) qs1 = ReservedName.objects.filter(order__gte=6) qs2 = ReservedName.objects.filter(order__lte=5) union_qs = qs1.union(qs2) for qs, expected_result in ( # Order by a single column. (union_qs.order_by("-pk").values_list("order", flat=True), [-1, 6, 5, 7]), (union_qs.order_by("pk").values_list("order", flat=True), [7, 5, 6, -1]), (union_qs.values_list("order", flat=True).order_by("-pk"), [-1, 6, 5, 7]), (union_qs.values_list("order", flat=True).order_by("pk"), [7, 5, 6, -1]), # Order by multiple columns. ( union_qs.order_by("-name", "pk").values_list("order", flat=True), [-1, 5, 7, 6], ), ( union_qs.values_list("order", flat=True).order_by("-name", "pk"), [-1, 5, 7, 6], ), ): with self.subTest(qs=qs): self.assertEqual(list(qs), expected_result) def test_union_with_values_list_and_order_on_annotation(self): qs1 = Number.objects.annotate( annotation=Value(-1), multiplier=F("annotation"), ).filter(num__gte=6) qs2 = Number.objects.annotate( annotation=Value(2), multiplier=F("annotation"), ).filter(num__lte=5) self.assertSequenceEqual( qs1.union(qs2).order_by("annotation", "num").values_list("num", flat=True), [6, 7, 8, 9, 0, 1, 2, 3, 4, 5], ) self.assertQuerysetEqual( qs1.union(qs2) .order_by( F("annotation") * F("multiplier"), "num", ) .values("num"), [6, 7, 8, 9, 0, 1, 2, 3, 4, 5], operator.itemgetter("num"), ) def test_union_multiple_models_with_values_list_and_order(self): reserved_name = ReservedName.objects.create(name="rn1", order=0) qs1 = Celebrity.objects.all() qs2 = ReservedName.objects.all() self.assertSequenceEqual( qs1.union(qs2).order_by("name").values_list("pk", flat=True), [reserved_name.pk], ) def test_union_multiple_models_with_values_list_and_order_by_extra_select(self): reserved_name = ReservedName.objects.create(name="rn1", order=0) qs1 = Celebrity.objects.extra(select={"extra_name": "name"}) qs2 = ReservedName.objects.extra(select={"extra_name": "name"}) self.assertSequenceEqual( qs1.union(qs2).order_by("extra_name").values_list("pk", flat=True), [reserved_name.pk], ) def test_union_in_subquery(self): ReservedName.objects.bulk_create( [ ReservedName(name="rn1", order=8), ReservedName(name="rn2", order=1), ReservedName(name="rn3", order=5), ] ) qs1 = Number.objects.filter(num__gt=7, num=OuterRef("order")) qs2 = Number.objects.filter(num__lt=2, num=OuterRef("order")) self.assertCountEqual( ReservedName.objects.annotate( number=Subquery(qs1.union(qs2).values("num")), ) .filter(number__isnull=False) .values_list("order", flat=True), [8, 1], ) def test_union_in_subquery_related_outerref(self): e1 = ExtraInfo.objects.create(value=7, info="e3") e2 = ExtraInfo.objects.create(value=5, info="e2") e3 = ExtraInfo.objects.create(value=1, info="e1") Author.objects.bulk_create( [ Author(name="a1", num=1, extra=e1), Author(name="a2", num=3, extra=e2), Author(name="a3", num=2, extra=e3), ] ) qs1 = ExtraInfo.objects.order_by().filter(value=OuterRef("num")) qs2 = ExtraInfo.objects.order_by().filter(value__lt=OuterRef("extra__value")) qs = ( Author.objects.annotate( info=Subquery(qs1.union(qs2).values("info")[:1]), ) .filter(info__isnull=False) .values_list("name", flat=True) ) self.assertCountEqual(qs, ["a1", "a2"]) # Combined queries don't mutate. self.assertCountEqual(qs, ["a1", "a2"]) def test_count_union(self): qs1 = Number.objects.filter(num__lte=1).values("num") qs2 = Number.objects.filter(num__gte=2, num__lte=3).values("num") self.assertEqual(qs1.union(qs2).count(), 4) def test_count_union_empty_result(self): qs = Number.objects.filter(pk__in=[]) self.assertEqual(qs.union(qs).count(), 0) @skipUnlessDBFeature("supports_select_difference") def test_count_difference(self): qs1 = Number.objects.filter(num__lt=10) qs2 = Number.objects.filter(num__lt=9) self.assertEqual(qs1.difference(qs2).count(), 1) @skipUnlessDBFeature("supports_select_intersection") def test_count_intersection(self): qs1 = Number.objects.filter(num__gte=5) qs2 = Number.objects.filter(num__lte=5) self.assertEqual(qs1.intersection(qs2).count(), 1) def test_exists_union(self): qs1 = Number.objects.filter(num__gte=5) qs2 = Number.objects.filter(num__lte=5) with CaptureQueriesContext(connection) as context: self.assertIs(qs1.union(qs2).exists(), True) captured_queries = context.captured_queries self.assertEqual(len(captured_queries), 1) captured_sql = captured_queries[0]["sql"] self.assertNotIn( connection.ops.quote_name(Number._meta.pk.column), captured_sql, ) self.assertEqual( captured_sql.count(connection.ops.limit_offset_sql(None, 1)), 3 if connection.features.supports_slicing_ordering_in_compound else 1, ) def test_exists_union_empty_result(self): qs = Number.objects.filter(pk__in=[]) self.assertIs(qs.union(qs).exists(), False) @skipUnlessDBFeature("supports_select_intersection") def test_exists_intersection(self): qs1 = Number.objects.filter(num__gt=5) qs2 = Number.objects.filter(num__lt=5) self.assertIs(qs1.intersection(qs1).exists(), True) self.assertIs(qs1.intersection(qs2).exists(), False) @skipUnlessDBFeature("supports_select_difference") def test_exists_difference(self): qs1 = Number.objects.filter(num__gte=5) qs2 = Number.objects.filter(num__gte=3) self.assertIs(qs1.difference(qs2).exists(), False) self.assertIs(qs2.difference(qs1).exists(), True) def test_get_union(self): qs = Number.objects.filter(num=2) self.assertEqual(qs.union(qs).get().num, 2) @skipUnlessDBFeature("supports_select_difference") def test_get_difference(self): qs1 = Number.objects.all() qs2 = Number.objects.exclude(num=2) self.assertEqual(qs1.difference(qs2).get().num, 2) @skipUnlessDBFeature("supports_select_intersection") def test_get_intersection(self): qs1 = Number.objects.all() qs2 = Number.objects.filter(num=2) self.assertEqual(qs1.intersection(qs2).get().num, 2) @skipUnlessDBFeature("supports_slicing_ordering_in_compound") def test_ordering_subqueries(self): qs1 = Number.objects.order_by("num")[:2] qs2 = Number.objects.order_by("-num")[:2] self.assertNumbersEqual(qs1.union(qs2).order_by("-num")[:4], [9, 8, 1, 0]) @skipIfDBFeature("supports_slicing_ordering_in_compound") def test_unsupported_ordering_slicing_raises_db_error(self): qs1 = Number.objects.all() qs2 = Number.objects.all() qs3 = Number.objects.all() msg = "LIMIT/OFFSET not allowed in subqueries of compound statements" with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2[:10])) msg = "ORDER BY not allowed in subqueries of compound statements" with self.assertRaisesMessage(DatabaseError, msg): list(qs1.order_by("id").union(qs2)) with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2).order_by("id").union(qs3)) @skipIfDBFeature("supports_select_intersection") def test_unsupported_intersection_raises_db_error(self): qs1 = Number.objects.all() qs2 = Number.objects.all() msg = "intersection is not supported on this database backend" with self.assertRaisesMessage(NotSupportedError, msg): list(qs1.intersection(qs2)) def test_combining_multiple_models(self): ReservedName.objects.create(name="99 little bugs", order=99) qs1 = Number.objects.filter(num=1).values_list("num", flat=True) qs2 = ReservedName.objects.values_list("order") self.assertEqual(list(qs1.union(qs2).order_by("num")), [1, 99]) def test_order_raises_on_non_selected_column(self): qs1 = ( Number.objects.filter() .annotate( annotation=Value(1, IntegerField()), ) .values("annotation", num2=F("num")) ) qs2 = Number.objects.filter().values("id", "num") # Should not raise list(qs1.union(qs2).order_by("annotation")) list(qs1.union(qs2).order_by("num2")) msg = "ORDER BY term does not match any column in the result set" # 'id' is not part of the select with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2).order_by("id")) # 'num' got realiased to num2 with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2).order_by("num")) with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2).order_by(F("num"))) with self.assertRaisesMessage(DatabaseError, msg): list(qs1.union(qs2).order_by(F("num").desc())) # switched order, now 'exists' again: list(qs2.union(qs1).order_by("num")) @skipUnlessDBFeature("supports_select_difference", "supports_select_intersection") def test_qs_with_subcompound_qs(self): qs1 = Number.objects.all() qs2 = Number.objects.intersection(Number.objects.filter(num__gt=1)) self.assertEqual(qs1.difference(qs2).count(), 2) def test_order_by_same_type(self): qs = Number.objects.all() union = qs.union(qs) numbers = list(range(10)) self.assertNumbersEqual(union.order_by("num"), numbers) self.assertNumbersEqual(union.order_by("other_num"), reversed(numbers)) def test_unsupported_operations_on_combined_qs(self): qs = Number.objects.all() msg = "Calling QuerySet.%s() after %s() is not supported." combinators = ["union"] if connection.features.supports_select_difference: combinators.append("difference") if connection.features.supports_select_intersection: combinators.append("intersection") for combinator in combinators: for operation in ( "alias", "annotate", "defer", "delete", "distinct", "exclude", "extra", "filter", "only", "prefetch_related", "select_related", "update", ): with self.subTest(combinator=combinator, operation=operation): with self.assertRaisesMessage( NotSupportedError, msg % (operation, combinator), ): getattr(getattr(qs, combinator)(qs), operation)() with self.assertRaisesMessage( NotSupportedError, msg % ("contains", combinator), ): obj = Number.objects.first() getattr(qs, combinator)(qs).contains(obj) def test_get_with_filters_unsupported_on_combined_qs(self): qs = Number.objects.all() msg = "Calling QuerySet.get(...) with filters after %s() is not supported." combinators = ["union"] if connection.features.supports_select_difference: combinators.append("difference") if connection.features.supports_select_intersection: combinators.append("intersection") for combinator in combinators: with self.subTest(combinator=combinator): with self.assertRaisesMessage(NotSupportedError, msg % combinator): getattr(qs, combinator)(qs).get(num=2) def test_operator_on_combined_qs_error(self): qs = Number.objects.all() msg = "Cannot use %s operator with combined queryset." combinators = ["union"] if connection.features.supports_select_difference: combinators.append("difference") if connection.features.supports_select_intersection: combinators.append("intersection") operators = [ ("|", operator.or_), ("&", operator.and_), ] for combinator in combinators: combined_qs = getattr(qs, combinator)(qs) for operator_, operator_func in operators: with self.subTest(combinator=combinator): with self.assertRaisesMessage(TypeError, msg % operator_): operator_func(qs, combined_qs) with self.assertRaisesMessage(TypeError, msg % operator_): operator_func(combined_qs, qs)
e1fbefcf93a2a7d88479a81e8dd3b9fb275b76ed15f7c8658abcfdb96620d442
import datetime from django.db import connection from django.test import TestCase, skipUnlessDBFeature from django.test.utils import CaptureQueriesContext from .models import DumbCategory, NonIntegerPKReturningModel, ReturningModel @skipUnlessDBFeature("can_return_columns_from_insert") class ReturningValuesTests(TestCase): def test_insert_returning(self): with CaptureQueriesContext(connection) as captured_queries: DumbCategory.objects.create() self.assertIn( "RETURNING %s.%s" % ( connection.ops.quote_name(DumbCategory._meta.db_table), connection.ops.quote_name(DumbCategory._meta.get_field("id").column), ), captured_queries[-1]["sql"], ) def test_insert_returning_non_integer(self): obj = NonIntegerPKReturningModel.objects.create() self.assertTrue(obj.created) self.assertIsInstance(obj.created, datetime.datetime) def test_insert_returning_multiple(self): with CaptureQueriesContext(connection) as captured_queries: obj = ReturningModel.objects.create() table_name = connection.ops.quote_name(ReturningModel._meta.db_table) self.assertIn( "RETURNING %s.%s, %s.%s" % ( table_name, connection.ops.quote_name(ReturningModel._meta.get_field("id").column), table_name, connection.ops.quote_name( ReturningModel._meta.get_field("created").column ), ), captured_queries[-1]["sql"], ) self.assertTrue(obj.pk) self.assertIsInstance(obj.created, datetime.datetime) @skipUnlessDBFeature("can_return_rows_from_bulk_insert") def test_bulk_insert(self): objs = [ReturningModel(), ReturningModel(pk=2**11), ReturningModel()] ReturningModel.objects.bulk_create(objs) for obj in objs: with self.subTest(obj=obj): self.assertTrue(obj.pk) self.assertIsInstance(obj.created, datetime.datetime)
1b5928b62b9efe7e10e9aa1449189311a26297522314aaa5104f50c4b87400d0
import json import unittest import xml.etree.ElementTree from django.db import NotSupportedError, connection, transaction from django.db.models import Count from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature from django.test.utils import CaptureQueriesContext from .models import Tag @skipUnlessDBFeature("supports_explaining_query_execution") class ExplainTests(TestCase): def test_basic(self): querysets = [ Tag.objects.filter(name="test"), Tag.objects.filter(name="test").select_related("parent"), Tag.objects.filter(name="test").prefetch_related("children"), Tag.objects.filter(name="test").annotate(Count("children")), Tag.objects.filter(name="test").values_list("name"), Tag.objects.order_by().union(Tag.objects.order_by().filter(name="test")), Tag.objects.select_for_update().filter(name="test"), ] supported_formats = connection.features.supported_explain_formats all_formats = ( (None,) + tuple(supported_formats) + tuple(f.lower() for f in supported_formats) ) for idx, queryset in enumerate(querysets): for format in all_formats: with self.subTest(format=format, queryset=idx): with self.assertNumQueries(1), CaptureQueriesContext( connection ) as captured_queries: result = queryset.explain(format=format) self.assertTrue( captured_queries[0]["sql"].startswith( connection.ops.explain_prefix ) ) self.assertIsInstance(result, str) self.assertTrue(result) if format == "xml": try: xml.etree.ElementTree.fromstring(result) except xml.etree.ElementTree.ParseError as e: self.fail( f"QuerySet.explain() result is not valid XML: {e}" ) elif format == "json": try: json.loads(result) except json.JSONDecodeError as e: self.fail( f"QuerySet.explain() result is not valid JSON: {e}" ) @skipUnlessDBFeature("validates_explain_options") def test_unknown_options(self): with self.assertRaisesMessage(ValueError, "Unknown options: test, test2"): Tag.objects.explain(test=1, test2=1) def test_unknown_format(self): msg = "DOES NOT EXIST is not a recognized format." if connection.features.supported_explain_formats: msg += " Allowed formats: %s" % ", ".join( sorted(connection.features.supported_explain_formats) ) with self.assertRaisesMessage(ValueError, msg): Tag.objects.explain(format="does not exist") @unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL specific") def test_postgres_options(self): qs = Tag.objects.filter(name="test") test_options = [ {"COSTS": False, "BUFFERS": True, "ANALYZE": True}, {"costs": False, "buffers": True, "analyze": True}, {"verbose": True, "timing": True, "analyze": True}, {"verbose": False, "timing": False, "analyze": True}, {"summary": True}, ] if connection.features.is_postgresql_12: test_options.append({"settings": True}) if connection.features.is_postgresql_13: test_options.append({"analyze": True, "wal": True}) for options in test_options: with self.subTest(**options), transaction.atomic(): with CaptureQueriesContext(connection) as captured_queries: qs.explain(format="text", **options) self.assertEqual(len(captured_queries), 1) for name, value in options.items(): option = "{} {}".format(name.upper(), "true" if value else "false") self.assertIn(option, captured_queries[0]["sql"]) @unittest.skipUnless(connection.vendor == "mysql", "MySQL specific") def test_mysql_text_to_traditional(self): # Ensure these cached properties are initialized to prevent queries for # the MariaDB or MySQL version during the QuerySet evaluation. connection.features.supported_explain_formats with CaptureQueriesContext(connection) as captured_queries: Tag.objects.filter(name="test").explain(format="text") self.assertEqual(len(captured_queries), 1) self.assertIn("FORMAT=TRADITIONAL", captured_queries[0]["sql"]) @unittest.skipUnless( connection.vendor == "mysql", "MariaDB and MySQL >= 8.0.18 specific." ) def test_mysql_analyze(self): qs = Tag.objects.filter(name="test") with CaptureQueriesContext(connection) as captured_queries: qs.explain(analyze=True) self.assertEqual(len(captured_queries), 1) prefix = "ANALYZE " if connection.mysql_is_mariadb else "EXPLAIN ANALYZE " self.assertTrue(captured_queries[0]["sql"].startswith(prefix)) with CaptureQueriesContext(connection) as captured_queries: qs.explain(analyze=True, format="JSON") self.assertEqual(len(captured_queries), 1) if connection.mysql_is_mariadb: self.assertIn("FORMAT=JSON", captured_queries[0]["sql"]) else: self.assertNotIn("FORMAT=JSON", captured_queries[0]["sql"]) @skipIfDBFeature("supports_explaining_query_execution") class ExplainUnsupportedTests(TestCase): def test_message(self): msg = "This backend does not support explaining query execution." with self.assertRaisesMessage(NotSupportedError, msg): Tag.objects.filter(name="test").explain()
4fe38eb723661bd6e55e63d9a946d803ec0bffcf326794c7d9479bbb5b6ba42c
from django.test import TestCase from .models import DumbCategory, NamedCategory, ProxyCategory class ContainsTests(TestCase): @classmethod def setUpTestData(cls): cls.category = DumbCategory.objects.create() cls.proxy_category = ProxyCategory.objects.create() def test_unsaved_obj(self): msg = "QuerySet.contains() cannot be used on unsaved objects." with self.assertRaisesMessage(ValueError, msg): DumbCategory.objects.contains(DumbCategory()) def test_obj_type(self): msg = "'obj' must be a model instance." with self.assertRaisesMessage(TypeError, msg): DumbCategory.objects.contains(object()) def test_values(self): msg = "Cannot call QuerySet.contains() after .values() or .values_list()." with self.assertRaisesMessage(TypeError, msg): DumbCategory.objects.values_list("pk").contains(self.category) with self.assertRaisesMessage(TypeError, msg): DumbCategory.objects.values("pk").contains(self.category) def test_basic(self): with self.assertNumQueries(1): self.assertIs(DumbCategory.objects.contains(self.category), True) # QuerySet.contains() doesn't evaluate a queryset. with self.assertNumQueries(1): self.assertIs(DumbCategory.objects.contains(self.category), True) def test_evaluated_queryset(self): qs = DumbCategory.objects.all() proxy_qs = ProxyCategory.objects.all() # Evaluate querysets. list(qs) list(proxy_qs) with self.assertNumQueries(0): self.assertIs(qs.contains(self.category), True) self.assertIs(qs.contains(self.proxy_category), True) self.assertIs(proxy_qs.contains(self.category), True) self.assertIs(proxy_qs.contains(self.proxy_category), True) def test_proxy_model(self): with self.assertNumQueries(1): self.assertIs(DumbCategory.objects.contains(self.proxy_category), True) with self.assertNumQueries(1): self.assertIs(ProxyCategory.objects.contains(self.category), True) def test_wrong_model(self): qs = DumbCategory.objects.all() named_category = NamedCategory(name="category") with self.assertNumQueries(0): self.assertIs(qs.contains(named_category), False) # Evaluate the queryset. list(qs) with self.assertNumQueries(0): self.assertIs(qs.contains(named_category), False)
cafb2734d71490d5b39885b7010d0784f37ef8bb40d11e3b6b8afd4c5a164cb7
from django.db import DEFAULT_DB_ALIAS, connection from django.db.models.sql import Query from django.test import SimpleTestCase from .models import Item class SQLCompilerTest(SimpleTestCase): def test_repr(self): query = Query(Item) compiler = query.get_compiler(DEFAULT_DB_ALIAS, connection) self.assertEqual( repr(compiler), f"<SQLCompiler model=Item connection=" f"<DatabaseWrapper vendor={connection.vendor!r} alias='default'> " f"using='default'>", )
37549bef217b6e21a3c286af0dbf946544f62f215dd68a001370f5e3d132080a
from datetime import datetime from django.core.exceptions import FieldError from django.db.models import BooleanField, CharField, F, Q from django.db.models.expressions import Col, Func from django.db.models.fields.related_lookups import RelatedIsNull from django.db.models.functions import Lower from django.db.models.lookups import Exact, GreaterThan, IsNull, LessThan from django.db.models.sql.query import JoinPromoter, Query from django.db.models.sql.where import OR from django.test import SimpleTestCase from django.test.utils import register_lookup from .models import Author, Item, ObjectC, Ranking class TestQuery(SimpleTestCase): def test_simple_query(self): query = Query(Author) where = query.build_where(Q(num__gt=2)) lookup = where.children[0] self.assertIsInstance(lookup, GreaterThan) self.assertEqual(lookup.rhs, 2) self.assertEqual(lookup.lhs.target, Author._meta.get_field("num")) def test_non_alias_cols_query(self): query = Query(Author, alias_cols=False) where = query.build_where(Q(num__gt=2, name__isnull=False) | Q(num__lt=F("id"))) name_isnull_lookup, num_gt_lookup = where.children[0].children self.assertIsInstance(num_gt_lookup, GreaterThan) self.assertIsInstance(num_gt_lookup.lhs, Col) self.assertIsNone(num_gt_lookup.lhs.alias) self.assertIsInstance(name_isnull_lookup, IsNull) self.assertIsInstance(name_isnull_lookup.lhs, Col) self.assertIsNone(name_isnull_lookup.lhs.alias) num_lt_lookup = where.children[1] self.assertIsInstance(num_lt_lookup, LessThan) self.assertIsInstance(num_lt_lookup.rhs, Col) self.assertIsNone(num_lt_lookup.rhs.alias) self.assertIsInstance(num_lt_lookup.lhs, Col) self.assertIsNone(num_lt_lookup.lhs.alias) def test_complex_query(self): query = Query(Author) where = query.build_where(Q(num__gt=2) | Q(num__lt=0)) self.assertEqual(where.connector, OR) lookup = where.children[0] self.assertIsInstance(lookup, GreaterThan) self.assertEqual(lookup.rhs, 2) self.assertEqual(lookup.lhs.target, Author._meta.get_field("num")) lookup = where.children[1] self.assertIsInstance(lookup, LessThan) self.assertEqual(lookup.rhs, 0) self.assertEqual(lookup.lhs.target, Author._meta.get_field("num")) def test_multiple_fields(self): query = Query(Item, alias_cols=False) where = query.build_where(Q(modified__gt=F("created"))) lookup = where.children[0] self.assertIsInstance(lookup, GreaterThan) self.assertIsInstance(lookup.rhs, Col) self.assertIsNone(lookup.rhs.alias) self.assertIsInstance(lookup.lhs, Col) self.assertIsNone(lookup.lhs.alias) self.assertEqual(lookup.rhs.target, Item._meta.get_field("created")) self.assertEqual(lookup.lhs.target, Item._meta.get_field("modified")) def test_transform(self): query = Query(Author, alias_cols=False) with register_lookup(CharField, Lower): where = query.build_where(~Q(name__lower="foo")) lookup = where.children[0] self.assertIsInstance(lookup, Exact) self.assertIsInstance(lookup.lhs, Lower) self.assertIsInstance(lookup.lhs.lhs, Col) self.assertIsNone(lookup.lhs.lhs.alias) self.assertEqual(lookup.lhs.lhs.target, Author._meta.get_field("name")) def test_negated_nullable(self): query = Query(Item) where = query.build_where(~Q(modified__lt=datetime(2017, 1, 1))) self.assertTrue(where.negated) lookup = where.children[0] self.assertIsInstance(lookup, LessThan) self.assertEqual(lookup.lhs.target, Item._meta.get_field("modified")) lookup = where.children[1] self.assertIsInstance(lookup, IsNull) self.assertEqual(lookup.lhs.target, Item._meta.get_field("modified")) def test_foreign_key(self): query = Query(Item) msg = "Joined field references are not permitted in this query" with self.assertRaisesMessage(FieldError, msg): query.build_where(Q(creator__num__gt=2)) def test_foreign_key_f(self): query = Query(Ranking) with self.assertRaises(FieldError): query.build_where(Q(rank__gt=F("author__num"))) def test_foreign_key_exclusive(self): query = Query(ObjectC, alias_cols=False) where = query.build_where(Q(objecta=None) | Q(objectb=None)) a_isnull = where.children[0] self.assertIsInstance(a_isnull, RelatedIsNull) self.assertIsInstance(a_isnull.lhs, Col) self.assertIsNone(a_isnull.lhs.alias) self.assertEqual(a_isnull.lhs.target, ObjectC._meta.get_field("objecta")) b_isnull = where.children[1] self.assertIsInstance(b_isnull, RelatedIsNull) self.assertIsInstance(b_isnull.lhs, Col) self.assertIsNone(b_isnull.lhs.alias) self.assertEqual(b_isnull.lhs.target, ObjectC._meta.get_field("objectb")) def test_clone_select_related(self): query = Query(Item) query.add_select_related(["creator"]) clone = query.clone() clone.add_select_related(["note", "creator__extra"]) self.assertEqual(query.select_related, {"creator": {}}) def test_iterable_lookup_value(self): query = Query(Item) where = query.build_where(Q(name=["a", "b"])) name_exact = where.children[0] self.assertIsInstance(name_exact, Exact) self.assertEqual(name_exact.rhs, "['a', 'b']") def test_filter_conditional(self): query = Query(Item) where = query.build_where(Func(output_field=BooleanField())) exact = where.children[0] self.assertIsInstance(exact, Exact) self.assertIsInstance(exact.lhs, Func) self.assertIs(exact.rhs, True) def test_filter_conditional_join(self): query = Query(Item) filter_expr = Func("note__note", output_field=BooleanField()) msg = "Joined field references are not permitted in this query" with self.assertRaisesMessage(FieldError, msg): query.build_where(filter_expr) def test_filter_non_conditional(self): query = Query(Item) msg = "Cannot filter against a non-conditional expression." with self.assertRaisesMessage(TypeError, msg): query.build_where(Func(output_field=CharField())) class JoinPromoterTest(SimpleTestCase): def test_repr(self): self.assertEqual( repr(JoinPromoter("AND", 3, True)), "JoinPromoter(connector='AND', num_children=3, negated=True)", )
91064b650ffef88dea4c845cbbbebe14796420a285df8232a77bb2953ffd4caf
import datetime from django.core.exceptions import FieldDoesNotExist from django.db.models import F from django.db.models.functions import Lower from django.db.utils import IntegrityError from django.test import TestCase, override_settings, skipUnlessDBFeature from .models import ( Article, CustomDbColumn, CustomPk, Detail, Food, Individual, JSONFieldNullable, Member, Note, Number, Order, Paragraph, RelatedObject, SingleObject, SpecialCategory, Tag, Valid, ) class WriteToOtherRouter: def db_for_write(self, model, **hints): return "other" class BulkUpdateNoteTests(TestCase): @classmethod def setUpTestData(cls): cls.notes = [Note.objects.create(note=str(i), misc=str(i)) for i in range(10)] def create_tags(self): self.tags = [Tag.objects.create(name=str(i)) for i in range(10)] def test_simple(self): for note in self.notes: note.note = "test-%s" % note.id with self.assertNumQueries(1): Note.objects.bulk_update(self.notes, ["note"]) self.assertCountEqual( Note.objects.values_list("note", flat=True), [cat.note for cat in self.notes], ) def test_multiple_fields(self): for note in self.notes: note.note = "test-%s" % note.id note.misc = "misc-%s" % note.id with self.assertNumQueries(1): Note.objects.bulk_update(self.notes, ["note", "misc"]) self.assertCountEqual( Note.objects.values_list("note", flat=True), [cat.note for cat in self.notes], ) self.assertCountEqual( Note.objects.values_list("misc", flat=True), [cat.misc for cat in self.notes], ) def test_batch_size(self): with self.assertNumQueries(len(self.notes)): Note.objects.bulk_update(self.notes, fields=["note"], batch_size=1) def test_unsaved_models(self): objs = self.notes + [Note(note="test", misc="test")] msg = "All bulk_update() objects must have a primary key set." with self.assertRaisesMessage(ValueError, msg): Note.objects.bulk_update(objs, fields=["note"]) def test_foreign_keys_do_not_lookup(self): self.create_tags() for note, tag in zip(self.notes, self.tags): note.tag = tag with self.assertNumQueries(1): Note.objects.bulk_update(self.notes, ["tag"]) self.assertSequenceEqual(Note.objects.filter(tag__isnull=False), self.notes) def test_set_field_to_null(self): self.create_tags() Note.objects.update(tag=self.tags[0]) for note in self.notes: note.tag = None Note.objects.bulk_update(self.notes, ["tag"]) self.assertCountEqual(Note.objects.filter(tag__isnull=True), self.notes) def test_set_mixed_fields_to_null(self): self.create_tags() midpoint = len(self.notes) // 2 top, bottom = self.notes[:midpoint], self.notes[midpoint:] for note in top: note.tag = None for note in bottom: note.tag = self.tags[0] Note.objects.bulk_update(self.notes, ["tag"]) self.assertCountEqual(Note.objects.filter(tag__isnull=True), top) self.assertCountEqual(Note.objects.filter(tag__isnull=False), bottom) def test_functions(self): Note.objects.update(note="TEST") for note in self.notes: note.note = Lower("note") Note.objects.bulk_update(self.notes, ["note"]) self.assertEqual(set(Note.objects.values_list("note", flat=True)), {"test"}) # Tests that use self.notes go here, otherwise put them in another class. class BulkUpdateTests(TestCase): databases = {"default", "other"} def test_no_fields(self): msg = "Field names must be given to bulk_update()." with self.assertRaisesMessage(ValueError, msg): Note.objects.bulk_update([], fields=[]) def test_invalid_batch_size(self): msg = "Batch size must be a positive integer." with self.assertRaisesMessage(ValueError, msg): Note.objects.bulk_update([], fields=["note"], batch_size=-1) def test_nonexistent_field(self): with self.assertRaisesMessage( FieldDoesNotExist, "Note has no field named 'nonexistent'" ): Note.objects.bulk_update([], ["nonexistent"]) pk_fields_error = "bulk_update() cannot be used with primary key fields." def test_update_primary_key(self): with self.assertRaisesMessage(ValueError, self.pk_fields_error): Note.objects.bulk_update([], ["id"]) def test_update_custom_primary_key(self): with self.assertRaisesMessage(ValueError, self.pk_fields_error): CustomPk.objects.bulk_update([], ["name"]) def test_empty_objects(self): with self.assertNumQueries(0): rows_updated = Note.objects.bulk_update([], ["note"]) self.assertEqual(rows_updated, 0) def test_large_batch(self): Note.objects.bulk_create( [Note(note=str(i), misc=str(i)) for i in range(0, 2000)] ) notes = list(Note.objects.all()) rows_updated = Note.objects.bulk_update(notes, ["note"]) self.assertEqual(rows_updated, 2000) def test_updated_rows_when_passing_duplicates(self): note = Note.objects.create(note="test-note", misc="test") rows_updated = Note.objects.bulk_update([note, note], ["note"]) self.assertEqual(rows_updated, 1) # Duplicates in different batches. rows_updated = Note.objects.bulk_update([note, note], ["note"], batch_size=1) self.assertEqual(rows_updated, 2) def test_only_concrete_fields_allowed(self): obj = Valid.objects.create(valid="test") detail = Detail.objects.create(data="test") paragraph = Paragraph.objects.create(text="test") Member.objects.create(name="test", details=detail) msg = "bulk_update() can only be used with concrete fields." with self.assertRaisesMessage(ValueError, msg): Detail.objects.bulk_update([detail], fields=["member"]) with self.assertRaisesMessage(ValueError, msg): Paragraph.objects.bulk_update([paragraph], fields=["page"]) with self.assertRaisesMessage(ValueError, msg): Valid.objects.bulk_update([obj], fields=["parent"]) def test_custom_db_columns(self): model = CustomDbColumn.objects.create(custom_column=1) model.custom_column = 2 CustomDbColumn.objects.bulk_update([model], fields=["custom_column"]) model.refresh_from_db() self.assertEqual(model.custom_column, 2) def test_custom_pk(self): custom_pks = [ CustomPk.objects.create(name="pk-%s" % i, extra="") for i in range(10) ] for model in custom_pks: model.extra = "extra-%s" % model.pk CustomPk.objects.bulk_update(custom_pks, ["extra"]) self.assertCountEqual( CustomPk.objects.values_list("extra", flat=True), [cat.extra for cat in custom_pks], ) def test_falsey_pk_value(self): order = Order.objects.create(pk=0, name="test") order.name = "updated" Order.objects.bulk_update([order], ["name"]) order.refresh_from_db() self.assertEqual(order.name, "updated") def test_inherited_fields(self): special_categories = [ SpecialCategory.objects.create(name=str(i), special_name=str(i)) for i in range(10) ] for category in special_categories: category.name = "test-%s" % category.id category.special_name = "special-test-%s" % category.special_name SpecialCategory.objects.bulk_update( special_categories, ["name", "special_name"] ) self.assertCountEqual( SpecialCategory.objects.values_list("name", flat=True), [cat.name for cat in special_categories], ) self.assertCountEqual( SpecialCategory.objects.values_list("special_name", flat=True), [cat.special_name for cat in special_categories], ) def test_field_references(self): numbers = [Number.objects.create(num=0) for _ in range(10)] for number in numbers: number.num = F("num") + 1 Number.objects.bulk_update(numbers, ["num"]) self.assertCountEqual(Number.objects.filter(num=1), numbers) def test_f_expression(self): notes = [ Note.objects.create(note="test_note", misc="test_misc") for _ in range(10) ] for note in notes: note.misc = F("note") Note.objects.bulk_update(notes, ["misc"]) self.assertCountEqual(Note.objects.filter(misc="test_note"), notes) def test_booleanfield(self): individuals = [Individual.objects.create(alive=False) for _ in range(10)] for individual in individuals: individual.alive = True Individual.objects.bulk_update(individuals, ["alive"]) self.assertCountEqual(Individual.objects.filter(alive=True), individuals) def test_ipaddressfield(self): for ip in ("2001::1", "1.2.3.4"): with self.subTest(ip=ip): models = [ CustomDbColumn.objects.create(ip_address="0.0.0.0") for _ in range(10) ] for model in models: model.ip_address = ip CustomDbColumn.objects.bulk_update(models, ["ip_address"]) self.assertCountEqual( CustomDbColumn.objects.filter(ip_address=ip), models ) def test_datetime_field(self): articles = [ Article.objects.create(name=str(i), created=datetime.datetime.today()) for i in range(10) ] point_in_time = datetime.datetime(1991, 10, 31) for article in articles: article.created = point_in_time Article.objects.bulk_update(articles, ["created"]) self.assertCountEqual(Article.objects.filter(created=point_in_time), articles) @skipUnlessDBFeature("supports_json_field") def test_json_field(self): JSONFieldNullable.objects.bulk_create( [JSONFieldNullable(json_field={"a": i}) for i in range(10)] ) objs = JSONFieldNullable.objects.all() for obj in objs: obj.json_field = {"c": obj.json_field["a"] + 1} JSONFieldNullable.objects.bulk_update(objs, ["json_field"]) self.assertCountEqual( JSONFieldNullable.objects.filter(json_field__has_key="c"), objs ) def test_nullable_fk_after_related_save(self): parent = RelatedObject.objects.create() child = SingleObject() parent.single = child parent.single.save() RelatedObject.objects.bulk_update([parent], fields=["single"]) self.assertEqual(parent.single_id, parent.single.pk) parent.refresh_from_db() self.assertEqual(parent.single, child) def test_unsaved_parent(self): parent = RelatedObject.objects.create() parent.single = SingleObject() msg = ( "bulk_update() prohibited to prevent data loss due to unsaved " "related object 'single'." ) with self.assertRaisesMessage(ValueError, msg): RelatedObject.objects.bulk_update([parent], fields=["single"]) def test_unspecified_unsaved_parent(self): parent = RelatedObject.objects.create() parent.single = SingleObject() parent.f = 42 RelatedObject.objects.bulk_update([parent], fields=["f"]) parent.refresh_from_db() self.assertEqual(parent.f, 42) self.assertIsNone(parent.single) @override_settings(DATABASE_ROUTERS=[WriteToOtherRouter()]) def test_database_routing(self): note = Note.objects.create(note="create") note.note = "bulk_update" with self.assertNumQueries(1, using="other"): Note.objects.bulk_update([note], fields=["note"]) @override_settings(DATABASE_ROUTERS=[WriteToOtherRouter()]) def test_database_routing_batch_atomicity(self): f1 = Food.objects.create(name="Banana") f2 = Food.objects.create(name="Apple") f1.name = "Kiwi" f2.name = "Kiwi" with self.assertRaises(IntegrityError): Food.objects.bulk_update([f1, f2], fields=["name"], batch_size=1) self.assertIs(Food.objects.filter(name="Kiwi").exists(), False)
16a42d687089f12f4fc835ca3d94d354d0cda673ef7bc0fa5b92db680b0edaa7
""" Testing some internals of the template processing. These are *not* examples to be copied in user code. """ from django.template import Library, TemplateSyntaxError from django.template.base import ( FilterExpression, Lexer, Parser, Token, TokenType, Variable, ) from django.template.defaultfilters import register as filter_library from django.test import SimpleTestCase 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_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({}) 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)
619a7a49b32fb606655b98b875519ea5210dbfcc836680ef2281545f91368471
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 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_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) 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")
2aa47859983dfac522bb50bdf301558b02c31cad5be05ae8ab8ff3ba0c00b86e
import sys from django.template import Context, Engine, TemplateDoesNotExist, TemplateSyntaxError from django.template.base import UNKNOWN_SOURCE from django.test import SimpleTestCase, override_settings from django.urls import NoReverseMatch from django.utils import translation from django.utils.html import escape class TemplateTestMixin: def _engine(self, **kwargs): return Engine(debug=self.debug_engine, **kwargs) def test_string_origin(self): template = self._engine().from_string("string template") self.assertEqual(template.origin.name, UNKNOWN_SOURCE) self.assertIsNone(template.origin.loader_name) self.assertEqual(template.source, "string template") @override_settings(SETTINGS_MODULE=None) def test_url_reverse_no_settings_module(self): """ #9005 -- url tag shouldn't require settings.SETTINGS_MODULE to be set. """ t = self._engine().from_string("{% url will_not_match %}") c = Context() with self.assertRaises(NoReverseMatch): t.render(c) def test_url_reverse_view_name(self): """ #19827 -- url tag should keep original strack trace when reraising exception. """ t = self._engine().from_string("{% url will_not_match %}") c = Context() try: t.render(c) except NoReverseMatch: tb = sys.exc_info()[2] depth = 0 while tb.tb_next is not None: tb = tb.tb_next depth += 1 self.assertGreater( depth, 5, "The traceback context was lost when reraising the traceback." ) def test_no_wrapped_exception(self): """ # 16770 -- The template system doesn't wrap exceptions, but annotates them. """ engine = self._engine() c = Context({"coconuts": lambda: 42 / 0}) t = engine.from_string("{{ coconuts }}") with self.assertRaises(ZeroDivisionError) as e: t.render(c) if self.debug_engine: debug = e.exception.template_debug self.assertEqual(debug["start"], 0) self.assertEqual(debug["end"], 14) def test_invalid_block_suggestion(self): """ Error messages should include the unexpected block name and be in all English. """ engine = self._engine() msg = ( "Invalid block tag on line 1: 'endblock', expected 'elif', 'else' " "or 'endif'. Did you forget to register or load this tag?" ) with self.settings(USE_I18N=True), translation.override("de"): with self.assertRaisesMessage(TemplateSyntaxError, msg): engine.from_string("{% if 1 %}lala{% endblock %}{% endif %}") def test_unknown_block_tag(self): engine = self._engine() msg = ( "Invalid block tag on line 1: 'foobar'. Did you forget to " "register or load this tag?" ) with self.assertRaisesMessage(TemplateSyntaxError, msg): engine.from_string("lala{% foobar %}") def test_compile_filter_expression_error(self): """ 19819 -- Make sure the correct token is highlighted for FilterExpression errors. """ engine = self._engine() msg = "Could not parse the remainder: '@bar' from 'foo@bar'" with self.assertRaisesMessage(TemplateSyntaxError, msg) as e: engine.from_string("{% if 1 %}{{ foo@bar }}{% endif %}") if self.debug_engine: debug = e.exception.template_debug self.assertEqual((debug["start"], debug["end"]), (10, 23)) self.assertEqual((debug["during"]), "{{ foo@bar }}") def test_compile_tag_error(self): """ Errors raised while compiling nodes should include the token information. """ engine = self._engine( libraries={"bad_tag": "template_tests.templatetags.bad_tag"}, ) with self.assertRaises(RuntimeError) as e: engine.from_string("{% load bad_tag %}{% badtag %}") if self.debug_engine: self.assertEqual(e.exception.template_debug["during"], "{% badtag %}") def test_compile_tag_error_27584(self): engine = self._engine( app_dirs=True, libraries={"tag_27584": "template_tests.templatetags.tag_27584"}, ) t = engine.get_template("27584_parent.html") with self.assertRaises(TemplateSyntaxError) as e: t.render(Context()) if self.debug_engine: self.assertEqual(e.exception.template_debug["during"], "{% badtag %}") def test_compile_tag_error_27956(self): """Errors in a child of {% extends %} are displayed correctly.""" engine = self._engine( app_dirs=True, libraries={"tag_27584": "template_tests.templatetags.tag_27584"}, ) t = engine.get_template("27956_child.html") with self.assertRaises(TemplateSyntaxError) as e: t.render(Context()) if self.debug_engine: self.assertEqual(e.exception.template_debug["during"], "{% badtag %}") def test_render_tag_error_in_extended_block(self): """Errors in extended block are displayed correctly.""" e = self._engine(app_dirs=True) template = e.get_template("test_extends_block_error.html") context = Context() with self.assertRaises(TemplateDoesNotExist) as cm: template.render(context) if self.debug_engine: self.assertEqual( cm.exception.template_debug["during"], escape('{% include "missing.html" %}'), ) def test_super_errors(self): """ #18169 -- NoReverseMatch should not be silence in block.super. """ engine = self._engine(app_dirs=True) t = engine.get_template("included_content.html") with self.assertRaises(NoReverseMatch): t.render(Context()) def test_extends_generic_template(self): """ #24338 -- Allow extending django.template.backends.django.Template objects. """ engine = self._engine() parent = engine.from_string("{% block content %}parent{% endblock %}") child = engine.from_string( "{% extends parent %}{% block content %}child{% endblock %}" ) self.assertEqual(child.render(Context({"parent": parent})), "child") def test_node_origin(self): """ #25848 -- Set origin on Node so debugging tools can determine which template the node came from even if extending or including templates. """ template = self._engine().from_string("content") for node in template.nodelist: self.assertEqual(node.origin, template.origin) class TemplateTests(TemplateTestMixin, SimpleTestCase): debug_engine = False class DebugTemplateTests(TemplateTestMixin, SimpleTestCase): debug_engine = True
f2323260923495439afe87792de47e1642013c8f44bf41c565374ce639bab8b1
from pathlib import Path from unittest import mock from django.template import autoreload from django.test import SimpleTestCase, override_settings from django.test.utils import require_jinja2 ROOT = Path(__file__).parent.absolute() EXTRA_TEMPLATES_DIR = ROOT / "templates_extra" @override_settings( INSTALLED_APPS=["template_tests"], TEMPLATES=[ { "BACKEND": "django.template.backends.dummy.TemplateStrings", "APP_DIRS": True, }, { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [EXTRA_TEMPLATES_DIR], "OPTIONS": { "context_processors": [ "django.template.context_processors.request", ], "loaders": [ "django.template.loaders.filesystem.Loader", "django.template.loaders.app_directories.Loader", ], }, }, ], ) class TemplateReloadTests(SimpleTestCase): @mock.patch("django.template.autoreload.reset_loaders") def test_template_changed(self, mock_reset): template_path = Path(__file__).parent / "templates" / "index.html" self.assertTrue(autoreload.template_changed(None, template_path)) mock_reset.assert_called_once() @mock.patch("django.template.autoreload.reset_loaders") def test_non_template_changed(self, mock_reset): self.assertIsNone(autoreload.template_changed(None, Path(__file__))) mock_reset.assert_not_called() @override_settings( TEMPLATES=[ { "DIRS": [ROOT], "BACKEND": "django.template.backends.django.DjangoTemplates", } ] ) @mock.patch("django.template.autoreload.reset_loaders") def test_non_template_changed_in_template_directory(self, mock_reset): self.assertIsNone(autoreload.template_changed(None, Path(__file__))) mock_reset.assert_not_called() def test_watch_for_template_changes(self): mock_reloader = mock.MagicMock() autoreload.watch_for_template_changes(mock_reloader) self.assertSequenceEqual( sorted(mock_reloader.watch_dir.call_args_list), [ mock.call(ROOT / "templates", "**/*"), mock.call(ROOT / "templates_extra", "**/*"), ], ) def test_get_template_directories(self): self.assertSetEqual( autoreload.get_template_directories(), { ROOT / "templates_extra", ROOT / "templates", }, ) @mock.patch("django.template.loaders.base.Loader.reset") def test_reset_all_loaders(self, mock_reset): autoreload.reset_loaders() self.assertEqual(mock_reset.call_count, 2) @override_settings( TEMPLATES=[ { "DIRS": [ str(ROOT) + "/absolute_str", "template_tests/relative_str", Path("template_tests/relative_path"), ], "BACKEND": "django.template.backends.django.DjangoTemplates", } ] ) def test_template_dirs_normalized_to_paths(self): self.assertSetEqual( autoreload.get_template_directories(), { ROOT / "absolute_str", Path.cwd() / "template_tests/relative_str", Path.cwd() / "template_tests/relative_path", }, ) @require_jinja2 @override_settings(INSTALLED_APPS=["template_tests"]) class Jinja2TemplateReloadTests(SimpleTestCase): def test_watch_for_template_changes(self): mock_reloader = mock.MagicMock() autoreload.watch_for_template_changes(mock_reloader) self.assertSequenceEqual( sorted(mock_reloader.watch_dir.call_args_list), [ mock.call(ROOT / "templates", "**/*"), ], ) def test_get_template_directories(self): self.assertSetEqual( autoreload.get_template_directories(), { ROOT / "templates", }, ) @mock.patch("django.template.loaders.base.Loader.reset") def test_reset_all_loaders(self, mock_reset): autoreload.reset_loaders() self.assertEqual(mock_reset.call_count, 0)
5234495d44bb8d5e09a1c3530bc2da2610bc4b03aae528cf02166350bb16dd4a
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"}})
53a31157971b90dacee4733dd4d7587b5f6d17870ac6ceea2b407fba47efe529
import functools from django.template import Library from django.template.base import Node from django.test import SimpleTestCase 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")) 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) 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 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, "")
8e30450c6891aff9a4e525625b61fed5478b0c8208aeb0de426e0b8d91ee4e83
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])
b80d7fd404b4465d94e4fba4cd01ee8569ec9a6dfb29bc04d2d9d5963b5c2194
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.""" var_names = [] for var in ("inf", "infinity", "iNFiniTy", "nan"): var_names.extend((var, "-" + var, "+" + var)) for var in var_names: with self.subTest(var=var): self.assertIsNone(Variable(var).literal)
e082e0f481593680e59010d611b46c6fbf59625b103d2db154bd76c727bbe775
from unittest import TestCase 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_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)
c69709c5acaa9b1422ba8783f35ed1d748056636f1a32f18a5d76a7929df46fa
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.0, 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)
d30dda9a4f2454c5eecf37e6b259e08333185c82709b6cfb157b30951bee4085
import functools import os 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): """ 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) @functools.wraps(func) def inner(self): # Set up custom template tag libraries if specified libraries = getattr(self, "libraries", {}) self.engine = Engine( libraries=libraries, loaders=loaders, ) func(self) if test_once: return func(self) 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 &gt; me")
42052c13de419e1f0b3c4ad698d7301f7b899d75d0398672d98451ffda67c762
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)
4ee0ec9e69c58bc19242cfc92ad7cd14ff44d8d4920e7abd82c590d720b495dd
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"), ]
cb0035b033447df6f395b863a30986e14a760b1d852bdafa81b5cb4cc50e6f3d
from django.urls import include, path, re_path from . import views ns_patterns = [ # Test urls for testing reverse lookups path("", views.index, name="index"), re_path(r"^client/([0-9,]+)/$", views.client, name="client"), re_path( r"^client/(?P<id>[0-9]+)/(?P<action>[^/]+)/$", views.client_action, name="client_action", ), re_path( r"^client/(?P<client_id>[0-9]+)/(?P<action>[^/]+)/$", views.client_action, name="client_action", ), re_path(r"^named-client/([0-9]+)/$", views.client2, name="named.client"), ] urlpatterns = ns_patterns + [ # Unicode strings are permitted everywhere. re_path(r"^Юникод/(\w+)/$", views.client2, name="метка_оператора"), re_path(r"^Юникод/(?P<tag>\S+)/$", views.client2, name="метка_оператора_2"), # Test urls for namespaces and current_app path("ns1/", include((ns_patterns, "app"), "ns1")), path("ns2/", include((ns_patterns, "app"))), ]
2dc1bc96ddcf380b0cf05e7d3eae63d294e150a87a77774165814e50600b4ba2
import unittest from django.template.smartif import IfParser class SmartIfTests(unittest.TestCase): def assertCalcEqual(self, expected, tokens): self.assertEqual(expected, IfParser(tokens).parse().eval({})) # We only test things here that are difficult to test elsewhere # Many other tests are found in the main tests for builtin template tags # Test parsing via the printed parse tree def test_not(self): var = IfParser(["not", False]).parse() self.assertEqual("(not (literal False))", repr(var)) self.assertTrue(var.eval({})) self.assertFalse(IfParser(["not", True]).parse().eval({})) def test_or(self): var = IfParser([True, "or", False]).parse() self.assertEqual("(or (literal True) (literal False))", repr(var)) self.assertTrue(var.eval({})) def test_in(self): list_ = [1, 2, 3] self.assertCalcEqual(True, [1, "in", list_]) self.assertCalcEqual(False, [1, "in", None]) self.assertCalcEqual(False, [None, "in", list_]) def test_not_in(self): list_ = [1, 2, 3] self.assertCalcEqual(False, [1, "not", "in", list_]) self.assertCalcEqual(True, [4, "not", "in", list_]) self.assertCalcEqual(False, [1, "not", "in", None]) self.assertCalcEqual(True, [None, "not", "in", list_]) def test_precedence(self): # (False and False) or True == True <- we want this one, like Python # False and (False or True) == False self.assertCalcEqual(True, [False, "and", False, "or", True]) # True or (False and False) == True <- we want this one, like Python # (True or False) and False == False self.assertCalcEqual(True, [True, "or", False, "and", False]) # (1 or 1) == 2 -> False # 1 or (1 == 2) -> True <- we want this one self.assertCalcEqual(True, [1, "or", 1, "==", 2]) self.assertCalcEqual(True, [True, "==", True, "or", True, "==", False]) self.assertEqual( "(or (and (== (literal 1) (literal 2)) (literal 3)) (literal 4))", repr(IfParser([1, "==", 2, "and", 3, "or", 4]).parse()), )
967dde811bf0e57a608d80ecdbf9ea96790778cce08b91a008cda68a1e0fb68f
# 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!")
7117cc34ed3a5b9db4f632ffbe5ba53b0e2f10cbd05d9f041ff075215a2bfeef
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")
c5a48fd662d2f468758ff4e0082114dd841cb2100e641708973b7b6e71165b8f
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 )
eba6da213f2de2af9d41277da33471f11f330775077e4d32f28409321666c11d
import os from django.template import Context, Engine, TemplateDoesNotExist from django.test import SimpleTestCase from .utils import ROOT 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")
5a7c8441606cb58da62eb8b735bba7192b77a21d1e435e864fe7a466c05b67b9
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")
179e022e87366aad2c475174b7869b89511965fdb7e65106a12c3291109108f1
import os from django.template import Context, Engine, TemplateSyntaxError from django.template.base import Node from django.template.library import InvalidTemplateLibrary 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 &amp; 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 &amp; 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 &amp; 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" ) self.verify_tag( custom.simple_tag_without_context_parameter, "simple_tag_without_context_parameter", ) 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): self.engine.from_string( "{% load custom %}{% simple_tag_without_context_parameter 123 %}" ) 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): self.engine.from_string( "{% load custom %}{% simple_tag_takes_context_without_params %}" ) 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): self.engine.from_string( "{% load inclusion %}{% inclusion_tag_without_context_parameter 123 %}" ) 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): self.engine.from_string( "{% load inclusion %}{% inclusion_tag_takes_context_without_params %}" ) 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", ), ( "{% load inclusion %}" "{% inclusion_unlimited_args_from_template 37 42 56 89 %}", "inclusion_unlimited_args_from_template - Expected result: 37, 42, 56, " "89\n", ), ( "{% load inclusion %}{% inclusion_only_unlimited_args_from_template %}", "inclusion_only_unlimited_args_from_template - Expected result: \n", ), ( "{% load inclusion %}" "{% inclusion_only_unlimited_args_from_template 37 42 56 89 %}", "inclusion_only_unlimited_args_from_template - Expected result: 37, " "42, 56, 89\n", ), ] for entry in templates: t = self.engine.from_string(entry[0]) self.assertEqual(t.render(c), entry[1]) def test_inclusion_tag_registration(self): # The decorators preserve the decorated function's docstring, name, # and attributes. self.verify_tag(inclusion.inclusion_no_params, "inclusion_no_params") self.verify_tag(inclusion.inclusion_one_param, "inclusion_one_param") self.verify_tag( inclusion.inclusion_explicit_no_context, "inclusion_explicit_no_context" ) self.verify_tag( inclusion.inclusion_no_params_with_context, "inclusion_no_params_with_context", ) self.verify_tag( inclusion.inclusion_params_and_context, "inclusion_params_and_context" ) self.verify_tag(inclusion.inclusion_two_params, "inclusion_two_params") self.verify_tag(inclusion.inclusion_one_default, "inclusion_one_default") self.verify_tag(inclusion.inclusion_unlimited_args, "inclusion_unlimited_args") self.verify_tag( inclusion.inclusion_only_unlimited_args, "inclusion_only_unlimited_args" ) self.verify_tag( inclusion.inclusion_tag_without_context_parameter, "inclusion_tag_without_context_parameter", ) self.verify_tag(inclusion.inclusion_tag_use_l10n, "inclusion_tag_use_l10n") self.verify_tag( inclusion.inclusion_unlimited_args_kwargs, "inclusion_unlimited_args_kwargs" ) def test_15070_use_l10n(self): """ Inclusion tag passes down `use_l10n` of context to the Context of the included/rendered template as well. """ c = Context({}) t = self.engine.from_string("{% load inclusion %}{% inclusion_tag_use_l10n %}") self.assertEqual(t.render(c).strip(), "None") c.use_l10n = True self.assertEqual(t.render(c).strip(), "True") def test_no_render_side_effect(self): """ #23441 -- InclusionNode shouldn't modify its nodelist at render time. """ engine = Engine(app_dirs=True, libraries=LIBRARIES) template = engine.from_string("{% load inclusion %}{% inclusion_no_params %}") count = template.nodelist.get_nodes_by_type(Node) template.render(Context({})) self.assertEqual(template.nodelist.get_nodes_by_type(Node), count) def test_render_context_is_cleared(self): """ #24555 -- InclusionNode should push and pop the render_context stack when rendering. Otherwise, leftover values such as blocks from extending can interfere with subsequent rendering. """ engine = Engine(app_dirs=True, libraries=LIBRARIES) template = engine.from_string( "{% load inclusion %}{% inclusion_extends1 %}{% inclusion_extends2 %}" ) self.assertEqual(template.render(Context({})).strip(), "one\ntwo") class TemplateTagLoadingTests(SimpleTestCase): @classmethod def setUpClass(cls): cls.egg_dir = os.path.join(ROOT, "eggs") super().setUpClass() def test_load_error(self): msg = ( "Invalid template library specified. ImportError raised when " "trying to load 'template_tests.broken_tag': cannot import name " "'Xtemplate'" ) with self.assertRaisesMessage(InvalidTemplateLibrary, msg): Engine(libraries={"broken_tag": "template_tests.broken_tag"}) def test_load_error_egg(self): egg_name = "%s/tagsegg.egg" % self.egg_dir msg = ( "Invalid template library specified. ImportError raised when " "trying to load 'tagsegg.templatetags.broken_egg': cannot " "import name 'Xtemplate'" ) with extend_sys_path(egg_name): with self.assertRaisesMessage(InvalidTemplateLibrary, msg): Engine(libraries={"broken_egg": "tagsegg.templatetags.broken_egg"}) def test_load_working_egg(self): ttext = "{% load working_egg %}" egg_name = "%s/tagsegg.egg" % self.egg_dir with extend_sys_path(egg_name): engine = Engine( libraries={ "working_egg": "tagsegg.templatetags.working_egg", } ) engine.from_string(ttext) def test_load_annotated_function(self): Engine( libraries={ "annotated_tag_function": "template_tests.annotated_tag_function", } )
0f8e744a08122aaf09979c026a1c905b9b89aa1b1be58e5e13753cd17091c950
import datetime from unittest import skipUnless from django.db import connection from django.db.models import CASCADE, ForeignKey, Index, Q from django.db.models.functions import Lower from django.test import ( TestCase, TransactionTestCase, skipIfDBFeature, skipUnlessDBFeature, ) from django.test.utils import override_settings from django.utils import timezone from .models import ( Article, ArticleTranslation, IndexedArticle2, IndexTogetherSingleList, ) class SchemaIndexesTests(TestCase): """ Test index handling by the db.backends.schema infrastructure. """ def test_index_name_hash(self): """ Index names should be deterministic. """ editor = connection.schema_editor() index_name = editor._create_index_name( table_name=Article._meta.db_table, column_names=("c1",), suffix="123", ) self.assertEqual(index_name, "indexes_article_c1_a52bd80b123") def test_index_name(self): """ Index names on the built-in database backends:: * Are truncated as needed. * Include all the column names. * Include a deterministic hash. """ long_name = "l%sng" % ("o" * 100) editor = connection.schema_editor() index_name = editor._create_index_name( table_name=Article._meta.db_table, column_names=("c1", "c2", long_name), suffix="ix", ) expected = { "mysql": "indexes_article_c1_c2_looooooooooooooooooo_255179b2ix", "oracle": "indexes_a_c1_c2_loo_255179b2ix", "postgresql": "indexes_article_c1_c2_loooooooooooooooooo_255179b2ix", "sqlite": "indexes_article_c1_c2_l%sng_255179b2ix" % ("o" * 100), } if connection.vendor not in expected: self.skipTest( "This test is only supported on the built-in database backends." ) self.assertEqual(index_name, expected[connection.vendor]) def test_index_together(self): editor = connection.schema_editor() index_sql = [str(statement) for statement in editor._model_indexes_sql(Article)] self.assertEqual(len(index_sql), 1) # Ensure the index name is properly quoted self.assertIn( connection.ops.quote_name( editor._create_index_name( Article._meta.db_table, ["headline", "pub_date"], suffix="_idx" ) ), index_sql[0], ) def test_index_together_single_list(self): # Test for using index_together with a single list (#22172) index_sql = connection.schema_editor()._model_indexes_sql( IndexTogetherSingleList ) self.assertEqual(len(index_sql), 1) def test_columns_list_sql(self): index = Index(fields=["headline"], name="whitespace_idx") editor = connection.schema_editor() self.assertIn( "(%s)" % editor.quote_name("headline"), str(index.create_sql(Article, editor)), ) def test_descending_columns_list_sql(self): index = Index(fields=["-headline"], name="whitespace_idx") editor = connection.schema_editor() self.assertIn( "(%s DESC)" % editor.quote_name("headline"), str(index.create_sql(Article, editor)), ) class SchemaIndexesNotPostgreSQLTests(TransactionTestCase): available_apps = ["indexes"] def test_create_index_ignores_opclasses(self): index = Index( name="test_ops_class", fields=["headline"], opclasses=["varchar_pattern_ops"], ) with connection.schema_editor() as editor: # This would error if opclasses weren't ignored. editor.add_index(IndexedArticle2, index) # The `condition` parameter is ignored by databases that don't support partial # indexes. @skipIfDBFeature("supports_partial_indexes") class PartialIndexConditionIgnoredTests(TransactionTestCase): available_apps = ["indexes"] def test_condition_ignored(self): index = Index( name="test_condition_ignored", fields=["published"], condition=Q(published=True), ) with connection.schema_editor() as editor: # This would error if condition weren't ignored. editor.add_index(Article, index) self.assertNotIn( "WHERE %s" % editor.quote_name("published"), str(index.create_sql(Article, editor)), ) @skipUnless(connection.vendor == "postgresql", "PostgreSQL tests") class SchemaIndexesPostgreSQLTests(TransactionTestCase): available_apps = ["indexes"] get_opclass_query = """ SELECT opcname, c.relname FROM pg_opclass AS oc JOIN pg_index as i on oc.oid = ANY(i.indclass) JOIN pg_class as c on c.oid = i.indexrelid WHERE c.relname = '%s' """ def test_text_indexes(self): """Test creation of PostgreSQL-specific text indexes (#12234)""" from .models import IndexedArticle index_sql = [ str(statement) for statement in connection.schema_editor()._model_indexes_sql( IndexedArticle ) ] self.assertEqual(len(index_sql), 5) self.assertIn('("headline" varchar_pattern_ops)', index_sql[1]) self.assertIn('("body" text_pattern_ops)', index_sql[3]) # unique=True and db_index=True should only create the varchar-specific # index (#19441). self.assertIn('("slug" varchar_pattern_ops)', index_sql[4]) def test_virtual_relation_indexes(self): """Test indexes are not created for related objects""" index_sql = connection.schema_editor()._model_indexes_sql(Article) self.assertEqual(len(index_sql), 1) def test_ops_class(self): index = Index( name="test_ops_class", fields=["headline"], opclasses=["varchar_pattern_ops"], ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % "test_ops_class") self.assertEqual( cursor.fetchall(), [("varchar_pattern_ops", "test_ops_class")] ) def test_ops_class_multiple_columns(self): index = Index( name="test_ops_class_multiple", fields=["headline", "body"], opclasses=["varchar_pattern_ops", "text_pattern_ops"], ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % "test_ops_class_multiple") expected_ops_classes = ( ("varchar_pattern_ops", "test_ops_class_multiple"), ("text_pattern_ops", "test_ops_class_multiple"), ) self.assertCountEqual(cursor.fetchall(), expected_ops_classes) def test_ops_class_partial(self): index = Index( name="test_ops_class_partial", fields=["body"], opclasses=["text_pattern_ops"], condition=Q(headline__contains="China"), ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % "test_ops_class_partial") self.assertCountEqual( cursor.fetchall(), [("text_pattern_ops", "test_ops_class_partial")] ) def test_ops_class_partial_tablespace(self): indexname = "test_ops_class_tblspace" index = Index( name=indexname, fields=["body"], opclasses=["text_pattern_ops"], condition=Q(headline__contains="China"), db_tablespace="pg_default", ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) self.assertIn( 'TABLESPACE "pg_default" ', str(index.create_sql(IndexedArticle2, editor)), ) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % indexname) self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)]) def test_ops_class_descending(self): indexname = "test_ops_class_ordered" index = Index( name=indexname, fields=["-body"], opclasses=["text_pattern_ops"], ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % indexname) self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)]) def test_ops_class_descending_partial(self): indexname = "test_ops_class_ordered_partial" index = Index( name=indexname, fields=["-body"], opclasses=["text_pattern_ops"], condition=Q(headline__contains="China"), ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % indexname) self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", indexname)]) @skipUnlessDBFeature("supports_covering_indexes") def test_ops_class_include(self): index_name = "test_ops_class_include" index = Index( name=index_name, fields=["body"], opclasses=["text_pattern_ops"], include=["headline"], ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % index_name) self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)]) @skipUnlessDBFeature("supports_covering_indexes") def test_ops_class_include_tablespace(self): index_name = "test_ops_class_include_tblspace" index = Index( name=index_name, fields=["body"], opclasses=["text_pattern_ops"], include=["headline"], db_tablespace="pg_default", ) with connection.schema_editor() as editor: editor.add_index(IndexedArticle2, index) self.assertIn( 'TABLESPACE "pg_default"', str(index.create_sql(IndexedArticle2, editor)), ) with editor.connection.cursor() as cursor: cursor.execute(self.get_opclass_query % index_name) self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)]) def test_ops_class_columns_lists_sql(self): index = Index( fields=["headline"], name="whitespace_idx", opclasses=["text_pattern_ops"], ) with connection.schema_editor() as editor: self.assertIn( "(%s text_pattern_ops)" % editor.quote_name("headline"), str(index.create_sql(Article, editor)), ) def test_ops_class_descending_columns_list_sql(self): index = Index( fields=["-headline"], name="whitespace_idx", opclasses=["text_pattern_ops"], ) with connection.schema_editor() as editor: self.assertIn( "(%s text_pattern_ops DESC)" % editor.quote_name("headline"), str(index.create_sql(Article, editor)), ) @skipUnless(connection.vendor == "mysql", "MySQL tests") class SchemaIndexesMySQLTests(TransactionTestCase): available_apps = ["indexes"] def test_no_index_for_foreignkey(self): """ MySQL on InnoDB already creates indexes automatically for foreign keys. (#14180). An index should be created if db_constraint=False (#26171). """ with connection.cursor() as cursor: storage = connection.introspection.get_storage_engine( cursor, ArticleTranslation._meta.db_table, ) if storage != "InnoDB": self.skip("This test only applies to the InnoDB storage engine") index_sql = [ str(statement) for statement in connection.schema_editor()._model_indexes_sql( ArticleTranslation ) ] self.assertEqual( index_sql, [ "CREATE INDEX " "`indexes_articletranslation_article_no_constraint_id_d6c0806b` " "ON `indexes_articletranslation` (`article_no_constraint_id`)" ], ) # The index also shouldn't be created if the ForeignKey is added after # the model was created. field_created = False try: with connection.schema_editor() as editor: new_field = ForeignKey(Article, CASCADE) new_field.set_attributes_from_name("new_foreign_key") editor.add_field(ArticleTranslation, new_field) field_created = True # No deferred SQL. The FK constraint is included in the # statement to add the field. self.assertFalse(editor.deferred_sql) finally: if field_created: with connection.schema_editor() as editor: editor.remove_field(ArticleTranslation, new_field) @skipUnlessDBFeature("supports_partial_indexes") # SQLite doesn't support timezone-aware datetimes when USE_TZ is False. @override_settings(USE_TZ=True) class PartialIndexTests(TransactionTestCase): # Schema editor is used to create the index to test that it works. available_apps = ["indexes"] def test_partial_index(self): with connection.schema_editor() as editor: index = Index( name="recent_article_idx", fields=["pub_date"], condition=Q( pub_date__gt=datetime.datetime( year=2015, month=1, day=1, # PostgreSQL would otherwise complain about the lookup # being converted to a mutable function (by removing # the timezone in the cast) which is forbidden. tzinfo=timezone.get_current_timezone(), ), ), ) self.assertIn( "WHERE %s" % editor.quote_name("pub_date"), str(index.create_sql(Article, schema_editor=editor)), ) editor.add_index(index=index, model=Article) with connection.cursor() as cursor: self.assertIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) editor.remove_index(index=index, model=Article) def test_integer_restriction_partial(self): with connection.schema_editor() as editor: index = Index( name="recent_article_idx", fields=["id"], condition=Q(pk__gt=1), ) self.assertIn( "WHERE %s" % editor.quote_name("id"), str(index.create_sql(Article, schema_editor=editor)), ) editor.add_index(index=index, model=Article) with connection.cursor() as cursor: self.assertIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) editor.remove_index(index=index, model=Article) def test_boolean_restriction_partial(self): with connection.schema_editor() as editor: index = Index( name="published_index", fields=["published"], condition=Q(published=True), ) self.assertIn( "WHERE %s" % editor.quote_name("published"), str(index.create_sql(Article, schema_editor=editor)), ) editor.add_index(index=index, model=Article) with connection.cursor() as cursor: self.assertIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) editor.remove_index(index=index, model=Article) @skipUnlessDBFeature("supports_functions_in_partial_indexes") def test_multiple_conditions(self): with connection.schema_editor() as editor: index = Index( name="recent_article_idx", fields=["pub_date", "headline"], condition=( Q( pub_date__gt=datetime.datetime( year=2015, month=1, day=1, tzinfo=timezone.get_current_timezone(), ) ) & Q(headline__contains="China") ), ) sql = str(index.create_sql(Article, schema_editor=editor)) where = sql.find("WHERE") self.assertIn("WHERE (%s" % editor.quote_name("pub_date"), sql) # Because each backend has different syntax for the operators, # check ONLY the occurrence of headline in the SQL. self.assertGreater(sql.rfind("headline"), where) editor.add_index(index=index, model=Article) with connection.cursor() as cursor: self.assertIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) editor.remove_index(index=index, model=Article) def test_is_null_condition(self): with connection.schema_editor() as editor: index = Index( name="recent_article_idx", fields=["pub_date"], condition=Q(pub_date__isnull=False), ) self.assertIn( "WHERE %s IS NOT NULL" % editor.quote_name("pub_date"), str(index.create_sql(Article, schema_editor=editor)), ) editor.add_index(index=index, model=Article) with connection.cursor() as cursor: self.assertIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) editor.remove_index(index=index, model=Article) @skipUnlessDBFeature("supports_expression_indexes") def test_partial_func_index(self): index_name = "partial_func_idx" index = Index( Lower("headline").desc(), name=index_name, condition=Q(pub_date__isnull=False), ) with connection.schema_editor() as editor: editor.add_index(index=index, model=Article) sql = index.create_sql(Article, schema_editor=editor) table = Article._meta.db_table self.assertIs(sql.references_column(table, "headline"), True) sql = str(sql) self.assertIn("LOWER(%s)" % editor.quote_name("headline"), sql) self.assertIn( "WHERE %s IS NOT NULL" % editor.quote_name("pub_date"), sql, ) self.assertGreater(sql.find("WHERE"), sql.find("LOWER")) with connection.cursor() as cursor: constraints = connection.introspection.get_constraints( cursor=cursor, table_name=table, ) self.assertIn(index_name, constraints) if connection.features.supports_index_column_ordering: self.assertEqual(constraints[index_name]["orders"], ["DESC"]) with connection.schema_editor() as editor: editor.remove_index(Article, index) with connection.cursor() as cursor: self.assertNotIn( index_name, connection.introspection.get_constraints( cursor=cursor, table_name=table, ), ) @skipUnlessDBFeature("supports_covering_indexes") class CoveringIndexTests(TransactionTestCase): available_apps = ["indexes"] def test_covering_index(self): index = Index( name="covering_headline_idx", fields=["headline"], include=["pub_date", "published"], ) with connection.schema_editor() as editor: self.assertIn( "(%s) INCLUDE (%s, %s)" % ( editor.quote_name("headline"), editor.quote_name("pub_date"), editor.quote_name("published"), ), str(index.create_sql(Article, editor)), ) editor.add_index(Article, index) with connection.cursor() as cursor: constraints = connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ) self.assertIn(index.name, constraints) self.assertEqual( constraints[index.name]["columns"], ["headline", "pub_date", "published"], ) editor.remove_index(Article, index) with connection.cursor() as cursor: self.assertNotIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) def test_covering_partial_index(self): index = Index( name="covering_partial_headline_idx", fields=["headline"], include=["pub_date"], condition=Q(pub_date__isnull=False), ) with connection.schema_editor() as editor: self.assertIn( "(%s) INCLUDE (%s) WHERE %s " % ( editor.quote_name("headline"), editor.quote_name("pub_date"), editor.quote_name("pub_date"), ), str(index.create_sql(Article, editor)), ) editor.add_index(Article, index) with connection.cursor() as cursor: constraints = connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ) self.assertIn(index.name, constraints) self.assertEqual( constraints[index.name]["columns"], ["headline", "pub_date"], ) editor.remove_index(Article, index) with connection.cursor() as cursor: self.assertNotIn( index.name, connection.introspection.get_constraints( cursor=cursor, table_name=Article._meta.db_table, ), ) @skipUnlessDBFeature("supports_expression_indexes") def test_covering_func_index(self): index_name = "covering_func_headline_idx" index = Index(Lower("headline"), name=index_name, include=["pub_date"]) with connection.schema_editor() as editor: editor.add_index(index=index, model=Article) sql = index.create_sql(Article, schema_editor=editor) table = Article._meta.db_table self.assertIs(sql.references_column(table, "headline"), True) sql = str(sql) self.assertIn("LOWER(%s)" % editor.quote_name("headline"), sql) self.assertIn("INCLUDE (%s)" % editor.quote_name("pub_date"), sql) self.assertGreater(sql.find("INCLUDE"), sql.find("LOWER")) with connection.cursor() as cursor: constraints = connection.introspection.get_constraints( cursor=cursor, table_name=table, ) self.assertIn(index_name, constraints) self.assertIn("pub_date", constraints[index_name]["columns"]) with connection.schema_editor() as editor: editor.remove_index(Article, index) with connection.cursor() as cursor: self.assertNotIn( index_name, connection.introspection.get_constraints( cursor=cursor, table_name=table, ), ) @skipIfDBFeature("supports_covering_indexes") class CoveringIndexIgnoredTests(TransactionTestCase): available_apps = ["indexes"] def test_covering_ignored(self): index = Index( name="test_covering_ignored", fields=["headline"], include=["pub_date"], ) with connection.schema_editor() as editor: editor.add_index(Article, index) self.assertNotIn( "INCLUDE (%s)" % editor.quote_name("headline"), str(index.create_sql(Article, editor)), )
8eafa6f4c796a4ef5a1d85b56fb5020f4f1b87abf098711b056595d2cd9490b2
from django.db import models class CurrentTranslation(models.ForeignObject): """ Creates virtual relation to the translation with model cache enabled. """ # Avoid validation requires_unique_target = False def __init__(self, to, on_delete, from_fields, to_fields, **kwargs): # Disable reverse relation kwargs["related_name"] = "+" # Set unique to enable model cache. kwargs["unique"] = True super().__init__(to, on_delete, from_fields, to_fields, **kwargs) class ArticleTranslation(models.Model): article = models.ForeignKey("indexes.Article", models.CASCADE) article_no_constraint = models.ForeignKey( "indexes.Article", models.CASCADE, db_constraint=False, related_name="+" ) language = models.CharField(max_length=10, unique=True) content = models.TextField() class Article(models.Model): headline = models.CharField(max_length=100) pub_date = models.DateTimeField() published = models.BooleanField(default=False) # Add virtual relation to the ArticleTranslation model. translation = CurrentTranslation( ArticleTranslation, models.CASCADE, ["id"], ["article"] ) class Meta: index_together = [ ["headline", "pub_date"], ] # Model for index_together being used only with single list class IndexTogetherSingleList(models.Model): headline = models.CharField(max_length=100) pub_date = models.DateTimeField() class Meta: index_together = ["headline", "pub_date"] class IndexedArticle(models.Model): headline = models.CharField(max_length=100, db_index=True) body = models.TextField(db_index=True) slug = models.CharField(max_length=40, unique=True) class Meta: required_db_features = {"supports_index_on_text_field"} class IndexedArticle2(models.Model): headline = models.CharField(max_length=100) body = models.TextField()
7ea43d5e10b5b4f3e41bb0a0c2c2c60a914e1af98799d697906b6746272a35e9
""" Tests for Django's bundled context processors. """ from django.test import SimpleTestCase, TestCase, override_settings @override_settings( ROOT_URLCONF="context_processors.urls", TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "APP_DIRS": True, "OPTIONS": { "context_processors": [ "django.template.context_processors.request", ], }, } ], ) class RequestContextProcessorTests(SimpleTestCase): """ Tests for the ``django.template.context_processors.request`` processor. """ def test_request_attributes(self): """ The request object is available in the template and that its attributes can't be overridden by GET and POST parameters (#3828). """ url = "/request_attrs/" # We should have the request object in the template. response = self.client.get(url) self.assertContains(response, "Have request") # Test is_secure. response = self.client.get(url) self.assertContains(response, "Not secure") response = self.client.get(url, {"is_secure": "blah"}) self.assertContains(response, "Not secure") response = self.client.post(url, {"is_secure": "blah"}) self.assertContains(response, "Not secure") # Test path. response = self.client.get(url) self.assertContains(response, url) response = self.client.get(url, {"path": "/blah/"}) self.assertContains(response, url) response = self.client.post(url, {"path": "/blah/"}) self.assertContains(response, url) @override_settings( DEBUG=True, INTERNAL_IPS=["127.0.0.1"], ROOT_URLCONF="context_processors.urls", TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "APP_DIRS": True, "OPTIONS": { "context_processors": [ "django.template.context_processors.debug", ], }, } ], ) class DebugContextProcessorTests(TestCase): """ Tests for the ``django.template.context_processors.debug`` processor. """ databases = {"default", "other"} def test_debug(self): url = "/debug/" # We should have the debug flag in the template. response = self.client.get(url) self.assertContains(response, "Have debug") # And now we should not with override_settings(DEBUG=False): response = self.client.get(url) self.assertNotContains(response, "Have debug") def test_sql_queries(self): """ Test whether sql_queries represents the actual amount of queries executed. (#23364) """ url = "/debug/" response = self.client.get(url) self.assertContains(response, "First query list: 0") self.assertContains(response, "Second query list: 1") # Check we have not actually memoized connection.queries self.assertContains(response, "Third query list: 2") # Check queries for DB connection 'other' self.assertContains(response, "Fourth query list: 3")
cc6cf239ed1592ed43128b0f0db557f688bdc21026522ad7a6bf97552757adcf
from django.urls import path from . import views urlpatterns = [ path("request_attrs/", views.request_processor), path("debug/", views.debug_processor), ]
0e2010f86bc9472c5083fbd2eda38cde85113bbc96da4164defa5effe31b6ae2
from django.shortcuts import render from .models import DebugObject def request_processor(request): return render(request, "context_processors/request_attrs.html") def debug_processor(request): context = { "debug_objects": DebugObject.objects, "other_debug_objects": DebugObject.objects.using("other"), } return render(request, "context_processors/debug.html", context)
4ba7e92cf9dfd318545233b3469a61539200fbce767338c332bc1aa4d457bd20
from datetime import date, datetime, timedelta from operator import attrgetter from django.db import IntegrityError from django.test import TestCase from .models import ( CustomMembership, Employee, Event, Friendship, Group, Ingredient, Invitation, Membership, Person, PersonChild, PersonSelfRefM2M, Recipe, RecipeIngredient, Relationship, SymmetricalFriendship, ) class M2mThroughTests(TestCase): @classmethod def setUpTestData(cls): cls.bob = Person.objects.create(name="Bob") cls.jim = Person.objects.create(name="Jim") cls.jane = Person.objects.create(name="Jane") cls.rock = Group.objects.create(name="Rock") cls.roll = Group.objects.create(name="Roll") def test_reverse_inherited_m2m_with_through_fields_list_hashable(self): reverse_m2m = Person._meta.get_field("events_invited") self.assertEqual(reverse_m2m.through_fields, ["event", "invitee"]) inherited_reverse_m2m = PersonChild._meta.get_field("events_invited") self.assertEqual(inherited_reverse_m2m.through_fields, ["event", "invitee"]) self.assertEqual(hash(reverse_m2m), hash(inherited_reverse_m2m)) def test_retrieve_intermediate_items(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jane, group=self.rock) expected = ["Jane", "Jim"] self.assertQuerysetEqual(self.rock.members.all(), expected, attrgetter("name")) def test_get_on_intermediate_model(self): Membership.objects.create(person=self.jane, group=self.rock) queryset = Membership.objects.get(person=self.jane, group=self.rock) self.assertEqual(repr(queryset), "<Membership: Jane is a member of Rock>") def test_filter_on_intermediate_model(self): m1 = Membership.objects.create(person=self.jim, group=self.rock) m2 = Membership.objects.create(person=self.jane, group=self.rock) queryset = Membership.objects.filter(group=self.rock) self.assertSequenceEqual(queryset, [m1, m2]) def test_add_on_m2m_with_intermediate_model(self): self.rock.members.add( self.bob, through_defaults={"invite_reason": "He is good."} ) self.assertSequenceEqual(self.rock.members.all(), [self.bob]) self.assertEqual(self.rock.membership_set.get().invite_reason, "He is good.") def test_add_on_m2m_with_intermediate_model_callable_through_default(self): def invite_reason_callable(): return "They were good at %s" % datetime.now() self.rock.members.add( self.bob, self.jane, through_defaults={"invite_reason": invite_reason_callable}, ) self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jane]) self.assertEqual( self.rock.membership_set.filter( invite_reason__startswith="They were good at ", ).count(), 2, ) # invite_reason_callable() is called once. self.assertEqual( self.bob.membership_set.get().invite_reason, self.jane.membership_set.get().invite_reason, ) def test_set_on_m2m_with_intermediate_model_callable_through_default(self): self.rock.members.set( [self.bob, self.jane], through_defaults={"invite_reason": lambda: "Why not?"}, ) self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jane]) self.assertEqual( self.rock.membership_set.filter( invite_reason__startswith="Why not?", ).count(), 2, ) def test_add_on_m2m_with_intermediate_model_value_required(self): self.rock.nodefaultsnonulls.add( self.jim, through_defaults={"nodefaultnonull": 1} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) def test_add_on_m2m_with_intermediate_model_value_required_fails(self): with self.assertRaises(IntegrityError): self.rock.nodefaultsnonulls.add(self.jim) def test_create_on_m2m_with_intermediate_model(self): annie = self.rock.members.create( name="Annie", through_defaults={"invite_reason": "She was just awesome."} ) self.assertSequenceEqual(self.rock.members.all(), [annie]) self.assertEqual( self.rock.membership_set.get().invite_reason, "She was just awesome." ) def test_create_on_m2m_with_intermediate_model_callable_through_default(self): annie = self.rock.members.create( name="Annie", through_defaults={"invite_reason": lambda: "She was just awesome."}, ) self.assertSequenceEqual(self.rock.members.all(), [annie]) self.assertEqual( self.rock.membership_set.get().invite_reason, "She was just awesome.", ) def test_create_on_m2m_with_intermediate_model_value_required(self): self.rock.nodefaultsnonulls.create( name="Test", through_defaults={"nodefaultnonull": 1} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) def test_create_on_m2m_with_intermediate_model_value_required_fails(self): with self.assertRaises(IntegrityError): self.rock.nodefaultsnonulls.create(name="Test") def test_get_or_create_on_m2m_with_intermediate_model_value_required(self): self.rock.nodefaultsnonulls.get_or_create( name="Test", through_defaults={"nodefaultnonull": 1} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) def test_get_or_create_on_m2m_with_intermediate_model_value_required_fails(self): with self.assertRaises(IntegrityError): self.rock.nodefaultsnonulls.get_or_create(name="Test") def test_update_or_create_on_m2m_with_intermediate_model_value_required(self): self.rock.nodefaultsnonulls.update_or_create( name="Test", through_defaults={"nodefaultnonull": 1} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) def test_update_or_create_on_m2m_with_intermediate_model_value_required_fails(self): with self.assertRaises(IntegrityError): self.rock.nodefaultsnonulls.update_or_create(name="Test") def test_remove_on_m2m_with_intermediate_model(self): Membership.objects.create(person=self.jim, group=self.rock) self.rock.members.remove(self.jim) self.assertSequenceEqual(self.rock.members.all(), []) def test_remove_on_m2m_with_intermediate_model_multiple(self): Membership.objects.create(person=self.jim, group=self.rock, invite_reason="1") Membership.objects.create(person=self.jim, group=self.rock, invite_reason="2") self.assertSequenceEqual(self.rock.members.all(), [self.jim, self.jim]) self.rock.members.remove(self.jim) self.assertSequenceEqual(self.rock.members.all(), []) def test_set_on_m2m_with_intermediate_model(self): members = list(Person.objects.filter(name__in=["Bob", "Jim"])) self.rock.members.set(members) self.assertSequenceEqual(self.rock.members.all(), [self.bob, self.jim]) def test_set_on_m2m_with_intermediate_model_value_required(self): self.rock.nodefaultsnonulls.set( [self.jim], through_defaults={"nodefaultnonull": 1} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) self.rock.nodefaultsnonulls.set( [self.jim], through_defaults={"nodefaultnonull": 2} ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 1) self.rock.nodefaultsnonulls.set( [self.jim], through_defaults={"nodefaultnonull": 2}, clear=True ) self.assertEqual(self.rock.testnodefaultsornulls_set.get().nodefaultnonull, 2) def test_set_on_m2m_with_intermediate_model_value_required_fails(self): with self.assertRaises(IntegrityError): self.rock.nodefaultsnonulls.set([self.jim]) def test_clear_removes_all_the_m2m_relationships(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jane, group=self.rock) self.rock.members.clear() self.assertQuerysetEqual(self.rock.members.all(), []) def test_retrieve_reverse_intermediate_items(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jim, group=self.roll) expected = ["Rock", "Roll"] self.assertQuerysetEqual(self.jim.group_set.all(), expected, attrgetter("name")) def test_add_on_reverse_m2m_with_intermediate_model(self): self.bob.group_set.add(self.rock) self.assertSequenceEqual(self.bob.group_set.all(), [self.rock]) def test_create_on_reverse_m2m_with_intermediate_model(self): funk = self.bob.group_set.create(name="Funk") self.assertSequenceEqual(self.bob.group_set.all(), [funk]) def test_remove_on_reverse_m2m_with_intermediate_model(self): Membership.objects.create(person=self.bob, group=self.rock) self.bob.group_set.remove(self.rock) self.assertSequenceEqual(self.bob.group_set.all(), []) def test_set_on_reverse_m2m_with_intermediate_model(self): members = list(Group.objects.filter(name__in=["Rock", "Roll"])) self.bob.group_set.set(members) self.assertSequenceEqual(self.bob.group_set.all(), [self.rock, self.roll]) def test_clear_on_reverse_removes_all_the_m2m_relationships(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jim, group=self.roll) self.jim.group_set.clear() self.assertQuerysetEqual(self.jim.group_set.all(), []) def test_query_model_by_attribute_name_of_related_model(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jane, group=self.rock) Membership.objects.create(person=self.bob, group=self.roll) Membership.objects.create(person=self.jim, group=self.roll) Membership.objects.create(person=self.jane, group=self.roll) self.assertQuerysetEqual( Group.objects.filter(members__name="Bob"), ["Roll"], attrgetter("name") ) def test_order_by_relational_field_through_model(self): today = datetime.now() yesterday = today - timedelta(days=1) CustomMembership.objects.create( person=self.jim, group=self.rock, date_joined=yesterday ) CustomMembership.objects.create( person=self.bob, group=self.rock, date_joined=today ) CustomMembership.objects.create( person=self.jane, group=self.roll, date_joined=yesterday ) CustomMembership.objects.create( person=self.jim, group=self.roll, date_joined=today ) self.assertSequenceEqual( self.rock.custom_members.order_by("custom_person_related_name"), [self.jim, self.bob], ) self.assertSequenceEqual( self.roll.custom_members.order_by("custom_person_related_name"), [self.jane, self.jim], ) def test_query_first_model_by_intermediate_model_attribute(self): Membership.objects.create( person=self.jane, group=self.roll, invite_reason="She was just awesome." ) Membership.objects.create( person=self.jim, group=self.roll, invite_reason="He is good." ) Membership.objects.create(person=self.bob, group=self.roll) qs = Group.objects.filter(membership__invite_reason="She was just awesome.") self.assertQuerysetEqual(qs, ["Roll"], attrgetter("name")) def test_query_second_model_by_intermediate_model_attribute(self): Membership.objects.create( person=self.jane, group=self.roll, invite_reason="She was just awesome." ) Membership.objects.create( person=self.jim, group=self.roll, invite_reason="He is good." ) Membership.objects.create(person=self.bob, group=self.roll) qs = Person.objects.filter(membership__invite_reason="She was just awesome.") self.assertQuerysetEqual(qs, ["Jane"], attrgetter("name")) def test_query_model_by_related_model_name(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create(person=self.jane, group=self.rock) Membership.objects.create(person=self.bob, group=self.roll) Membership.objects.create(person=self.jim, group=self.roll) Membership.objects.create(person=self.jane, group=self.roll) self.assertQuerysetEqual( Person.objects.filter(group__name="Rock"), ["Jane", "Jim"], attrgetter("name"), ) def test_query_model_by_custom_related_name(self): CustomMembership.objects.create(person=self.bob, group=self.rock) CustomMembership.objects.create(person=self.jim, group=self.rock) self.assertQuerysetEqual( Person.objects.filter(custom__name="Rock"), ["Bob", "Jim"], attrgetter("name"), ) def test_query_model_by_intermediate_can_return_non_unique_queryset(self): Membership.objects.create(person=self.jim, group=self.rock) Membership.objects.create( person=self.jane, group=self.rock, date_joined=datetime(2006, 1, 1) ) Membership.objects.create( person=self.bob, group=self.roll, date_joined=datetime(2004, 1, 1) ) Membership.objects.create(person=self.jim, group=self.roll) Membership.objects.create( person=self.jane, group=self.roll, date_joined=datetime(2004, 1, 1) ) qs = Person.objects.filter(membership__date_joined__gt=datetime(2004, 1, 1)) self.assertQuerysetEqual(qs, ["Jane", "Jim", "Jim"], attrgetter("name")) def test_custom_related_name_forward_empty_qs(self): self.assertQuerysetEqual(self.rock.custom_members.all(), []) def test_custom_related_name_reverse_empty_qs(self): self.assertQuerysetEqual(self.bob.custom.all(), []) def test_custom_related_name_forward_non_empty_qs(self): CustomMembership.objects.create(person=self.bob, group=self.rock) CustomMembership.objects.create(person=self.jim, group=self.rock) self.assertQuerysetEqual( self.rock.custom_members.all(), ["Bob", "Jim"], attrgetter("name") ) def test_custom_related_name_reverse_non_empty_qs(self): CustomMembership.objects.create(person=self.bob, group=self.rock) CustomMembership.objects.create(person=self.jim, group=self.rock) self.assertQuerysetEqual(self.bob.custom.all(), ["Rock"], attrgetter("name")) def test_custom_related_name_doesnt_conflict_with_fky_related_name(self): c = CustomMembership.objects.create(person=self.bob, group=self.rock) self.assertSequenceEqual(self.bob.custom_person_related_name.all(), [c]) def test_through_fields(self): """ Relations with intermediary tables with multiple FKs to the M2M's ``to`` model are possible. """ event = Event.objects.create(title="Rockwhale 2014") Invitation.objects.create(event=event, inviter=self.bob, invitee=self.jim) Invitation.objects.create(event=event, inviter=self.bob, invitee=self.jane) self.assertQuerysetEqual( event.invitees.all(), ["Jane", "Jim"], attrgetter("name") ) class M2mThroughReferentialTests(TestCase): def test_self_referential_empty_qs(self): tony = PersonSelfRefM2M.objects.create(name="Tony") self.assertQuerysetEqual(tony.friends.all(), []) def test_self_referential_non_symmetrical_first_side(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") Friendship.objects.create( first=tony, second=chris, date_friended=datetime.now() ) self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name")) def test_self_referential_non_symmetrical_second_side(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") Friendship.objects.create( first=tony, second=chris, date_friended=datetime.now() ) self.assertQuerysetEqual(chris.friends.all(), []) def test_self_referential_non_symmetrical_clear_first_side(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") Friendship.objects.create( first=tony, second=chris, date_friended=datetime.now() ) chris.friends.clear() self.assertQuerysetEqual(chris.friends.all(), []) # Since this isn't a symmetrical relation, Tony's friend link still exists. self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name")) def test_self_referential_non_symmetrical_both(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") Friendship.objects.create( first=tony, second=chris, date_friended=datetime.now() ) Friendship.objects.create( first=chris, second=tony, date_friended=datetime.now() ) self.assertQuerysetEqual(tony.friends.all(), ["Chris"], attrgetter("name")) self.assertQuerysetEqual(chris.friends.all(), ["Tony"], attrgetter("name")) def test_through_fields_self_referential(self): john = Employee.objects.create(name="john") peter = Employee.objects.create(name="peter") mary = Employee.objects.create(name="mary") harry = Employee.objects.create(name="harry") Relationship.objects.create(source=john, target=peter, another=None) Relationship.objects.create(source=john, target=mary, another=None) Relationship.objects.create(source=john, target=harry, another=peter) self.assertQuerysetEqual( john.subordinates.all(), ["peter", "mary", "harry"], attrgetter("name") ) def test_self_referential_symmetrical(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") SymmetricalFriendship.objects.create( first=tony, second=chris, date_friended=date.today(), ) self.assertSequenceEqual(tony.sym_friends.all(), [chris]) # Manually created symmetrical m2m relation doesn't add mirror entry # automatically. self.assertSequenceEqual(chris.sym_friends.all(), []) SymmetricalFriendship.objects.create( first=chris, second=tony, date_friended=date.today() ) self.assertSequenceEqual(chris.sym_friends.all(), [tony]) def test_add_on_symmetrical_m2m_with_intermediate_model(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") date_friended = date(2017, 1, 3) tony.sym_friends.add(chris, through_defaults={"date_friended": date_friended}) self.assertSequenceEqual(tony.sym_friends.all(), [chris]) self.assertSequenceEqual(chris.sym_friends.all(), [tony]) friendship = tony.symmetricalfriendship_set.get() self.assertEqual(friendship.date_friended, date_friended) def test_set_on_symmetrical_m2m_with_intermediate_model(self): tony = PersonSelfRefM2M.objects.create(name="Tony") chris = PersonSelfRefM2M.objects.create(name="Chris") anne = PersonSelfRefM2M.objects.create(name="Anne") kate = PersonSelfRefM2M.objects.create(name="Kate") date_friended_add = date(2013, 1, 5) date_friended_set = date.today() tony.sym_friends.add( anne, chris, through_defaults={"date_friended": date_friended_add}, ) tony.sym_friends.set( [anne, kate], through_defaults={"date_friended": date_friended_set}, ) self.assertSequenceEqual(tony.sym_friends.all(), [anne, kate]) self.assertSequenceEqual(anne.sym_friends.all(), [tony]) self.assertSequenceEqual(kate.sym_friends.all(), [tony]) self.assertEqual( kate.symmetricalfriendship_set.get().date_friended, date_friended_set, ) # Date is preserved. self.assertEqual( anne.symmetricalfriendship_set.get().date_friended, date_friended_add, ) # Recreate relationship. tony.sym_friends.set( [anne], clear=True, through_defaults={"date_friended": date_friended_set}, ) self.assertSequenceEqual(tony.sym_friends.all(), [anne]) self.assertSequenceEqual(anne.sym_friends.all(), [tony]) self.assertEqual( anne.symmetricalfriendship_set.get().date_friended, date_friended_set, ) class M2mThroughToFieldsTests(TestCase): @classmethod def setUpTestData(cls): cls.pea = Ingredient.objects.create(iname="pea") cls.potato = Ingredient.objects.create(iname="potato") cls.tomato = Ingredient.objects.create(iname="tomato") cls.curry = Recipe.objects.create(rname="curry") RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.potato) RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.pea) RecipeIngredient.objects.create(recipe=cls.curry, ingredient=cls.tomato) def test_retrieval(self): # Forward retrieval self.assertSequenceEqual( self.curry.ingredients.all(), [self.pea, self.potato, self.tomato] ) # Backward retrieval self.assertEqual(self.tomato.recipes.get(), self.curry) def test_choices(self): field = Recipe._meta.get_field("ingredients") self.assertEqual( [choice[0] for choice in field.get_choices(include_blank=False)], ["pea", "potato", "tomato"], )
fe76878f6d969b156009c5e081a335fe92e1f74fdcddfdeffb3ab18822fe9415
from datetime import datetime from django.db import models # M2M described on one of the models class Person(models.Model): name = models.CharField(max_length=128) class Meta: ordering = ("name",) class PersonChild(Person): pass class Group(models.Model): name = models.CharField(max_length=128) members = models.ManyToManyField(Person, through="Membership") custom_members = models.ManyToManyField( Person, through="CustomMembership", related_name="custom" ) nodefaultsnonulls = models.ManyToManyField( Person, through="TestNoDefaultsOrNulls", related_name="testnodefaultsnonulls", ) class Meta: ordering = ("name",) class Membership(models.Model): person = models.ForeignKey(Person, models.CASCADE) group = models.ForeignKey(Group, models.CASCADE) date_joined = models.DateTimeField(default=datetime.now) invite_reason = models.CharField(max_length=64, null=True) class Meta: ordering = ("date_joined", "invite_reason", "group") def __str__(self): return "%s is a member of %s" % (self.person.name, self.group.name) class CustomMembership(models.Model): person = models.ForeignKey( Person, models.CASCADE, db_column="custom_person_column", related_name="custom_person_related_name", ) group = models.ForeignKey(Group, models.CASCADE) weird_fk = models.ForeignKey(Membership, models.SET_NULL, null=True) date_joined = models.DateTimeField(default=datetime.now) class Meta: db_table = "test_table" ordering = ["date_joined"] def __str__(self): return "%s is a member of %s" % (self.person.name, self.group.name) class TestNoDefaultsOrNulls(models.Model): person = models.ForeignKey(Person, models.CASCADE) group = models.ForeignKey(Group, models.CASCADE) nodefaultnonull = models.IntegerField() class PersonSelfRefM2M(models.Model): name = models.CharField(max_length=5) friends = models.ManyToManyField("self", through="Friendship", symmetrical=False) sym_friends = models.ManyToManyField( "self", through="SymmetricalFriendship", symmetrical=True ) class Friendship(models.Model): first = models.ForeignKey( PersonSelfRefM2M, models.CASCADE, related_name="rel_from_set" ) second = models.ForeignKey( PersonSelfRefM2M, models.CASCADE, related_name="rel_to_set" ) date_friended = models.DateTimeField() class SymmetricalFriendship(models.Model): first = models.ForeignKey(PersonSelfRefM2M, models.CASCADE) second = models.ForeignKey(PersonSelfRefM2M, models.CASCADE, related_name="+") date_friended = models.DateField() # Custom through link fields class Event(models.Model): title = models.CharField(max_length=50) invitees = models.ManyToManyField( to=Person, through="Invitation", through_fields=["event", "invitee"], related_name="events_invited", ) class Invitation(models.Model): event = models.ForeignKey(Event, models.CASCADE, related_name="invitations") # field order is deliberately inverted. the target field is "invitee". inviter = models.ForeignKey(Person, models.CASCADE, related_name="invitations_sent") invitee = models.ForeignKey(Person, models.CASCADE, related_name="invitations") class Employee(models.Model): name = models.CharField(max_length=5) subordinates = models.ManyToManyField( "self", through="Relationship", through_fields=("source", "target"), symmetrical=False, ) class Meta: ordering = ("pk",) class Relationship(models.Model): # field order is deliberately inverted. another = models.ForeignKey( Employee, models.SET_NULL, related_name="rel_another_set", null=True ) target = models.ForeignKey(Employee, models.CASCADE, related_name="rel_target_set") source = models.ForeignKey(Employee, models.CASCADE, related_name="rel_source_set") class Ingredient(models.Model): iname = models.CharField(max_length=20, unique=True) class Meta: ordering = ("iname",) class Recipe(models.Model): rname = models.CharField(max_length=20, unique=True) ingredients = models.ManyToManyField( Ingredient, through="RecipeIngredient", related_name="recipes", ) class Meta: ordering = ("rname",) class RecipeIngredient(models.Model): ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field="iname") recipe = models.ForeignKey(Recipe, models.CASCADE, to_field="rname")
67e979bc9a135744a323cff3396bf7af3021e1d75942ae9bf39a13fe4b7ddce1
import datetime import re from datetime import date from decimal import Decimal from django import forms from django.core.exceptions import ImproperlyConfigured from django.db import models from django.forms.models import ( BaseModelFormSet, _get_foreign_key, inlineformset_factory, modelformset_factory, ) from django.http import QueryDict from django.test import TestCase, skipUnlessDBFeature from .models import ( AlternateBook, Author, AuthorMeeting, BetterAuthor, Book, BookWithCustomPK, BookWithOptionalAltEditor, ClassyMexicanRestaurant, CustomPrimaryKey, Location, Membership, MexicanRestaurant, Owner, OwnerProfile, Person, Place, Player, Poem, Poet, Post, Price, Product, Repository, Restaurant, Revision, Team, ) class DeletionTests(TestCase): def test_deletion(self): PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True) poet = Poet.objects.create(name="test") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "0", "form-0-id": str(poet.pk), "form-0-name": "test", "form-0-DELETE": "on", } formset = PoetFormSet(data, queryset=Poet.objects.all()) formset.save(commit=False) self.assertEqual(Poet.objects.count(), 1) formset.save() self.assertTrue(formset.is_valid()) self.assertEqual(Poet.objects.count(), 0) def test_add_form_deletion_when_invalid(self): """ Make sure that an add form that is filled out, but marked for deletion doesn't cause validation errors. """ PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True) poet = Poet.objects.create(name="test") # One existing untouched and two new unvalid forms data = { "form-TOTAL_FORMS": "3", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "0", "form-0-id": str(poet.id), "form-0-name": "test", "form-1-id": "", "form-1-name": "x" * 1000, # Too long "form-2-id": str(poet.id), # Violate unique constraint "form-2-name": "test2", } formset = PoetFormSet(data, queryset=Poet.objects.all()) # Make sure this form doesn't pass validation. self.assertIs(formset.is_valid(), False) self.assertEqual(Poet.objects.count(), 1) # Then make sure that it *does* pass validation and delete the object, # even though the data in new forms aren't actually valid. data["form-0-DELETE"] = "on" data["form-1-DELETE"] = "on" data["form-2-DELETE"] = "on" formset = PoetFormSet(data, queryset=Poet.objects.all()) self.assertIs(formset.is_valid(), True) formset.save() self.assertEqual(Poet.objects.count(), 0) def test_change_form_deletion_when_invalid(self): """ Make sure that a change form that is filled out, but marked for deletion doesn't cause validation errors. """ PoetFormSet = modelformset_factory(Poet, fields="__all__", can_delete=True) poet = Poet.objects.create(name="test") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "0", "form-0-id": str(poet.id), "form-0-name": "x" * 1000, } formset = PoetFormSet(data, queryset=Poet.objects.all()) # Make sure this form doesn't pass validation. self.assertIs(formset.is_valid(), False) self.assertEqual(Poet.objects.count(), 1) # Then make sure that it *does* pass validation and delete the object, # even though the data isn't actually valid. data["form-0-DELETE"] = "on" formset = PoetFormSet(data, queryset=Poet.objects.all()) self.assertIs(formset.is_valid(), True) formset.save() self.assertEqual(Poet.objects.count(), 0) def test_outdated_deletion(self): poet = Poet.objects.create(name="test") poem = Poem.objects.create(name="Brevity is the soul of wit", poet=poet) PoemFormSet = inlineformset_factory( Poet, Poem, fields="__all__", can_delete=True ) # Simulate deletion of an object that doesn't exist in the database data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "2", "form-0-id": str(poem.pk), "form-0-name": "foo", "form-1-id": str(poem.pk + 1), # doesn't exist "form-1-name": "bar", "form-1-DELETE": "on", } formset = PoemFormSet(data, instance=poet, prefix="form") # The formset is valid even though poem.pk + 1 doesn't exist, # because it's marked for deletion anyway self.assertTrue(formset.is_valid()) formset.save() # Make sure the save went through correctly self.assertEqual(Poem.objects.get(pk=poem.pk).name, "foo") self.assertEqual(poet.poem_set.count(), 1) self.assertFalse(Poem.objects.filter(pk=poem.pk + 1).exists()) class ModelFormsetTest(TestCase): def test_modelformset_factory_without_fields(self): """Regression for #19733""" message = ( "Calling modelformset_factory without defining 'fields' or 'exclude' " "explicitly is prohibited." ) with self.assertRaisesMessage(ImproperlyConfigured, message): modelformset_factory(Author) def test_simple_save(self): qs = Author.objects.all() AuthorFormSet = modelformset_factory(Author, fields="__all__", extra=3) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 3) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-name">Name:</label>' '<input id="id_form-0-name" type="text" name="form-0-name" maxlength="100">' '<input type="hidden" name="form-0-id" id="id_form-0-id"></p>', ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_form-1-name">Name:</label>' '<input id="id_form-1-name" type="text" name="form-1-name" maxlength="100">' '<input type="hidden" name="form-1-id" id="id_form-1-id"></p>', ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_form-2-name">Name:</label>' '<input id="id_form-2-name" type="text" name="form-2-name" maxlength="100">' '<input type="hidden" name="form-2-id" id="id_form-2-id"></p>', ) data = { "form-TOTAL_FORMS": "3", # the number of forms rendered "form-INITIAL_FORMS": "0", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-name": "Charles Baudelaire", "form-1-name": "Arthur Rimbaud", "form-2-name": "", } formset = AuthorFormSet(data=data, queryset=qs) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 2) author1, author2 = saved self.assertEqual(author1, Author.objects.get(name="Charles Baudelaire")) self.assertEqual(author2, Author.objects.get(name="Arthur Rimbaud")) authors = list(Author.objects.order_by("name")) self.assertEqual(authors, [author2, author1]) # Gah! We forgot Paul Verlaine. Let's create a formset to edit the # existing authors with an extra form to add him. We *could* pass in a # queryset to restrict the Author objects we edit, but in this case # we'll use it to display them in alphabetical order by name. qs = Author.objects.order_by("name") AuthorFormSet = modelformset_factory( Author, fields="__all__", extra=1, can_delete=False ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 3) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-name">Name:</label>' '<input id="id_form-0-name" type="text" name="form-0-name" ' 'value="Arthur Rimbaud" maxlength="100">' '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id"></p>' % author2.id, ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_form-1-name">Name:</label>' '<input id="id_form-1-name" type="text" name="form-1-name" ' 'value="Charles Baudelaire" maxlength="100">' '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id"></p>' % author1.id, ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_form-2-name">Name:</label>' '<input id="id_form-2-name" type="text" name="form-2-name" maxlength="100">' '<input type="hidden" name="form-2-id" id="id_form-2-id"></p>', ) data = { "form-TOTAL_FORMS": "3", # the number of forms rendered "form-INITIAL_FORMS": "2", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-id": str(author2.id), "form-0-name": "Arthur Rimbaud", "form-1-id": str(author1.id), "form-1-name": "Charles Baudelaire", "form-2-name": "Paul Verlaine", } formset = AuthorFormSet(data=data, queryset=qs) self.assertTrue(formset.is_valid()) # Only changed or new objects are returned from formset.save() saved = formset.save() self.assertEqual(len(saved), 1) author3 = saved[0] self.assertEqual(author3, Author.objects.get(name="Paul Verlaine")) authors = list(Author.objects.order_by("name")) self.assertEqual(authors, [author2, author1, author3]) # This probably shouldn't happen, but it will. If an add form was # marked for deletion, make sure we don't save that form. qs = Author.objects.order_by("name") AuthorFormSet = modelformset_factory( Author, fields="__all__", extra=1, can_delete=True ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 4) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-name">Name:</label>' '<input id="id_form-0-name" type="text" name="form-0-name" ' 'value="Arthur Rimbaud" maxlength="100"></p>' '<p><label for="id_form-0-DELETE">Delete:</label>' '<input type="checkbox" name="form-0-DELETE" id="id_form-0-DELETE">' '<input type="hidden" name="form-0-id" value="%d" id="id_form-0-id"></p>' % author2.id, ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_form-1-name">Name:</label>' '<input id="id_form-1-name" type="text" name="form-1-name" ' 'value="Charles Baudelaire" maxlength="100"></p>' '<p><label for="id_form-1-DELETE">Delete:</label>' '<input type="checkbox" name="form-1-DELETE" id="id_form-1-DELETE">' '<input type="hidden" name="form-1-id" value="%d" id="id_form-1-id"></p>' % author1.id, ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_form-2-name">Name:</label>' '<input id="id_form-2-name" type="text" name="form-2-name" ' 'value="Paul Verlaine" maxlength="100"></p>' '<p><label for="id_form-2-DELETE">Delete:</label>' '<input type="checkbox" name="form-2-DELETE" id="id_form-2-DELETE">' '<input type="hidden" name="form-2-id" value="%d" id="id_form-2-id"></p>' % author3.id, ) self.assertHTMLEqual( formset.forms[3].as_p(), '<p><label for="id_form-3-name">Name:</label>' '<input id="id_form-3-name" type="text" name="form-3-name" maxlength="100">' '</p><p><label for="id_form-3-DELETE">Delete:</label>' '<input type="checkbox" name="form-3-DELETE" id="id_form-3-DELETE">' '<input type="hidden" name="form-3-id" id="id_form-3-id"></p>', ) data = { "form-TOTAL_FORMS": "4", # the number of forms rendered "form-INITIAL_FORMS": "3", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-id": str(author2.id), "form-0-name": "Arthur Rimbaud", "form-1-id": str(author1.id), "form-1-name": "Charles Baudelaire", "form-2-id": str(author3.id), "form-2-name": "Paul Verlaine", "form-3-name": "Walt Whitman", "form-3-DELETE": "on", } formset = AuthorFormSet(data=data, queryset=qs) self.assertTrue(formset.is_valid()) # No objects were changed or saved so nothing will come back. self.assertEqual(formset.save(), []) authors = list(Author.objects.order_by("name")) self.assertEqual(authors, [author2, author1, author3]) # Let's edit a record to ensure save only returns that one record. data = { "form-TOTAL_FORMS": "4", # the number of forms rendered "form-INITIAL_FORMS": "3", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-id": str(author2.id), "form-0-name": "Walt Whitman", "form-1-id": str(author1.id), "form-1-name": "Charles Baudelaire", "form-2-id": str(author3.id), "form-2-name": "Paul Verlaine", "form-3-name": "", "form-3-DELETE": "", } formset = AuthorFormSet(data=data, queryset=qs) self.assertTrue(formset.is_valid()) # One record has changed. saved = formset.save() self.assertEqual(len(saved), 1) self.assertEqual(saved[0], Author.objects.get(name="Walt Whitman")) def test_commit_false(self): # Test the behavior of commit=False and save_m2m author1 = Author.objects.create(name="Charles Baudelaire") author2 = Author.objects.create(name="Paul Verlaine") author3 = Author.objects.create(name="Walt Whitman") meeting = AuthorMeeting.objects.create(created=date.today()) meeting.authors.set(Author.objects.all()) # create an Author instance to add to the meeting. author4 = Author.objects.create(name="John Steinbeck") AuthorMeetingFormSet = modelformset_factory( AuthorMeeting, fields="__all__", extra=1, can_delete=True ) data = { "form-TOTAL_FORMS": "2", # the number of forms rendered "form-INITIAL_FORMS": "1", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-id": str(meeting.id), "form-0-name": "2nd Tuesday of the Week Meeting", "form-0-authors": [author2.id, author1.id, author3.id, author4.id], "form-1-name": "", "form-1-authors": "", "form-1-DELETE": "", } formset = AuthorMeetingFormSet(data=data, queryset=AuthorMeeting.objects.all()) self.assertTrue(formset.is_valid()) instances = formset.save(commit=False) for instance in instances: instance.created = date.today() instance.save() formset.save_m2m() self.assertSequenceEqual( instances[0].authors.all(), [author1, author4, author2, author3], ) def test_max_num(self): # Test the behavior of max_num with model formsets. It should allow # all existing related objects/inlines for a given object to be # displayed, but not allow the creation of new inlines beyond max_num. a1 = Author.objects.create(name="Charles Baudelaire") a2 = Author.objects.create(name="Paul Verlaine") a3 = Author.objects.create(name="Walt Whitman") qs = Author.objects.order_by("name") AuthorFormSet = modelformset_factory( Author, fields="__all__", max_num=None, extra=3 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 6) self.assertEqual(len(formset.extra_forms), 3) AuthorFormSet = modelformset_factory( Author, fields="__all__", max_num=4, extra=3 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 4) self.assertEqual(len(formset.extra_forms), 1) AuthorFormSet = modelformset_factory( Author, fields="__all__", max_num=0, extra=3 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 3) self.assertEqual(len(formset.extra_forms), 0) AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=None) formset = AuthorFormSet(queryset=qs) self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=0) formset = AuthorFormSet(queryset=qs) self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) AuthorFormSet = modelformset_factory(Author, fields="__all__", max_num=4) formset = AuthorFormSet(queryset=qs) self.assertSequenceEqual(formset.get_queryset(), [a1, a2, a3]) def test_min_num(self): # Test the behavior of min_num with model formsets. It should be # added to extra. qs = Author.objects.none() AuthorFormSet = modelformset_factory(Author, fields="__all__", extra=0) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 0) AuthorFormSet = modelformset_factory( Author, fields="__all__", min_num=1, extra=0 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 1) AuthorFormSet = modelformset_factory( Author, fields="__all__", min_num=1, extra=1 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 2) def test_min_num_with_existing(self): # Test the behavior of min_num with existing objects. Author.objects.create(name="Charles Baudelaire") qs = Author.objects.all() AuthorFormSet = modelformset_factory( Author, fields="__all__", extra=0, min_num=1 ) formset = AuthorFormSet(queryset=qs) self.assertEqual(len(formset.forms), 1) def test_custom_save_method(self): class PoetForm(forms.ModelForm): def save(self, commit=True): # change the name to "Vladimir Mayakovsky" just to be a jerk. author = super().save(commit=False) author.name = "Vladimir Mayakovsky" if commit: author.save() return author PoetFormSet = modelformset_factory(Poet, fields="__all__", form=PoetForm) data = { "form-TOTAL_FORMS": "3", # the number of forms rendered "form-INITIAL_FORMS": "0", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-name": "Walt Whitman", "form-1-name": "Charles Baudelaire", "form-2-name": "", } qs = Poet.objects.all() formset = PoetFormSet(data=data, queryset=qs) self.assertTrue(formset.is_valid()) poets = formset.save() self.assertEqual(len(poets), 2) poet1, poet2 = poets self.assertEqual(poet1.name, "Vladimir Mayakovsky") self.assertEqual(poet2.name, "Vladimir Mayakovsky") def test_custom_form(self): """ model_formset_factory() respects fields and exclude parameters of a custom form. """ class PostForm1(forms.ModelForm): class Meta: model = Post fields = ("title", "posted") class PostForm2(forms.ModelForm): class Meta: model = Post exclude = ("subtitle",) PostFormSet = modelformset_factory(Post, form=PostForm1) formset = PostFormSet() self.assertNotIn("subtitle", formset.forms[0].fields) PostFormSet = modelformset_factory(Post, form=PostForm2) formset = PostFormSet() self.assertNotIn("subtitle", formset.forms[0].fields) def test_custom_queryset_init(self): """ A queryset can be overridden in the formset's __init__() method. """ Author.objects.create(name="Charles Baudelaire") Author.objects.create(name="Paul Verlaine") class BaseAuthorFormSet(BaseModelFormSet): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.queryset = Author.objects.filter(name__startswith="Charles") AuthorFormSet = modelformset_factory( Author, fields="__all__", formset=BaseAuthorFormSet ) formset = AuthorFormSet() self.assertEqual(len(formset.get_queryset()), 1) def test_model_inheritance(self): BetterAuthorFormSet = modelformset_factory(BetterAuthor, fields="__all__") formset = BetterAuthorFormSet() self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-name">Name:</label>' '<input id="id_form-0-name" type="text" name="form-0-name" maxlength="100">' '</p><p><label for="id_form-0-write_speed">Write speed:</label>' '<input type="number" name="form-0-write_speed" id="id_form-0-write_speed">' '<input type="hidden" name="form-0-author_ptr" id="id_form-0-author_ptr">' "</p>", ) data = { "form-TOTAL_FORMS": "1", # the number of forms rendered "form-INITIAL_FORMS": "0", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-author_ptr": "", "form-0-name": "Ernest Hemingway", "form-0-write_speed": "10", } formset = BetterAuthorFormSet(data) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (author1,) = saved self.assertEqual(author1, BetterAuthor.objects.get(name="Ernest Hemingway")) hemingway_id = BetterAuthor.objects.get(name="Ernest Hemingway").pk formset = BetterAuthorFormSet() self.assertEqual(len(formset.forms), 2) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-name">Name:</label>' '<input id="id_form-0-name" type="text" name="form-0-name" ' 'value="Ernest Hemingway" maxlength="100"></p>' '<p><label for="id_form-0-write_speed">Write speed:</label>' '<input type="number" name="form-0-write_speed" value="10" ' 'id="id_form-0-write_speed">' '<input type="hidden" name="form-0-author_ptr" value="%d" ' 'id="id_form-0-author_ptr"></p>' % hemingway_id, ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_form-1-name">Name:</label>' '<input id="id_form-1-name" type="text" name="form-1-name" maxlength="100">' '</p><p><label for="id_form-1-write_speed">Write speed:</label>' '<input type="number" name="form-1-write_speed" id="id_form-1-write_speed">' '<input type="hidden" name="form-1-author_ptr" id="id_form-1-author_ptr">' "</p>", ) data = { "form-TOTAL_FORMS": "2", # the number of forms rendered "form-INITIAL_FORMS": "1", # the number of forms with initial data "form-MAX_NUM_FORMS": "", # the max number of forms "form-0-author_ptr": hemingway_id, "form-0-name": "Ernest Hemingway", "form-0-write_speed": "10", "form-1-author_ptr": "", "form-1-name": "", "form-1-write_speed": "", } formset = BetterAuthorFormSet(data) self.assertTrue(formset.is_valid()) self.assertEqual(formset.save(), []) def test_inline_formsets(self): # We can also create a formset that is tied to a parent model. This is # how the admin system's edit inline functionality works. AuthorBooksFormSet = inlineformset_factory( Author, Book, can_delete=False, extra=3, fields="__all__" ) author = Author.objects.create(name="Charles Baudelaire") formset = AuthorBooksFormSet(instance=author) self.assertEqual(len(formset.forms), 3) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_book_set-0-title">Title:</label>' '<input id="id_book_set-0-title" type="text" name="book_set-0-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-0-author" value="%d" ' 'id="id_book_set-0-author">' '<input type="hidden" name="book_set-0-id" id="id_book_set-0-id">' "</p>" % author.id, ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_book_set-1-title">Title:</label>' '<input id="id_book_set-1-title" type="text" name="book_set-1-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-1-author" value="%d" ' 'id="id_book_set-1-author">' '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>' % author.id, ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_book_set-2-title">Title:</label>' '<input id="id_book_set-2-title" type="text" name="book_set-2-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-2-author" value="%d" ' 'id="id_book_set-2-author">' '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>' % author.id, ) data = { "book_set-TOTAL_FORMS": "3", # the number of forms rendered "book_set-INITIAL_FORMS": "0", # the number of forms with initial data "book_set-MAX_NUM_FORMS": "", # the max number of forms "book_set-0-title": "Les Fleurs du Mal", "book_set-1-title": "", "book_set-2-title": "", } formset = AuthorBooksFormSet(data, instance=author) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (book1,) = saved self.assertEqual(book1, Book.objects.get(title="Les Fleurs du Mal")) self.assertSequenceEqual(author.book_set.all(), [book1]) # Now that we've added a book to Charles Baudelaire, let's try adding # another one. This time though, an edit form will be available for # every existing book. AuthorBooksFormSet = inlineformset_factory( Author, Book, can_delete=False, extra=2, fields="__all__" ) author = Author.objects.get(name="Charles Baudelaire") formset = AuthorBooksFormSet(instance=author) self.assertEqual(len(formset.forms), 3) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_book_set-0-title">Title:</label>' '<input id="id_book_set-0-title" type="text" name="book_set-0-title" ' 'value="Les Fleurs du Mal" maxlength="100">' '<input type="hidden" name="book_set-0-author" value="%d" ' 'id="id_book_set-0-author">' '<input type="hidden" name="book_set-0-id" value="%d" ' 'id="id_book_set-0-id"></p>' % ( author.id, book1.id, ), ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_book_set-1-title">Title:</label>' '<input id="id_book_set-1-title" type="text" name="book_set-1-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-1-author" value="%d" ' 'id="id_book_set-1-author">' '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>' % author.id, ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_book_set-2-title">Title:</label>' '<input id="id_book_set-2-title" type="text" name="book_set-2-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-2-author" value="%d" ' 'id="id_book_set-2-author">' '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>' % author.id, ) data = { "book_set-TOTAL_FORMS": "3", # the number of forms rendered "book_set-INITIAL_FORMS": "1", # the number of forms with initial data "book_set-MAX_NUM_FORMS": "", # the max number of forms "book_set-0-id": str(book1.id), "book_set-0-title": "Les Fleurs du Mal", "book_set-1-title": "Les Paradis Artificiels", "book_set-2-title": "", } formset = AuthorBooksFormSet(data, instance=author) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (book2,) = saved self.assertEqual(book2, Book.objects.get(title="Les Paradis Artificiels")) # As you can see, 'Les Paradis Artificiels' is now a book belonging to # Charles Baudelaire. self.assertSequenceEqual(author.book_set.order_by("title"), [book1, book2]) def test_inline_formsets_save_as_new(self): # The save_as_new parameter lets you re-associate the data to a new # instance. This is used in the admin for save_as functionality. AuthorBooksFormSet = inlineformset_factory( Author, Book, can_delete=False, extra=2, fields="__all__" ) Author.objects.create(name="Charles Baudelaire") # An immutable QueryDict simulates request.POST. data = QueryDict(mutable=True) data.update( { "book_set-TOTAL_FORMS": "3", # the number of forms rendered "book_set-INITIAL_FORMS": "2", # the number of forms with initial data "book_set-MAX_NUM_FORMS": "", # the max number of forms "book_set-0-id": "1", "book_set-0-title": "Les Fleurs du Mal", "book_set-1-id": "2", "book_set-1-title": "Les Paradis Artificiels", "book_set-2-title": "", } ) data._mutable = False formset = AuthorBooksFormSet(data, instance=Author(), save_as_new=True) self.assertTrue(formset.is_valid()) self.assertIs(data._mutable, False) new_author = Author.objects.create(name="Charles Baudelaire") formset = AuthorBooksFormSet(data, instance=new_author, save_as_new=True) saved = formset.save() self.assertEqual(len(saved), 2) book1, book2 = saved self.assertEqual(book1.title, "Les Fleurs du Mal") self.assertEqual(book2.title, "Les Paradis Artificiels") # Test using a custom prefix on an inline formset. formset = AuthorBooksFormSet(prefix="test") self.assertEqual(len(formset.forms), 2) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_test-0-title">Title:</label>' '<input id="id_test-0-title" type="text" name="test-0-title" ' 'maxlength="100">' '<input type="hidden" name="test-0-author" id="id_test-0-author">' '<input type="hidden" name="test-0-id" id="id_test-0-id"></p>', ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_test-1-title">Title:</label>' '<input id="id_test-1-title" type="text" name="test-1-title" ' 'maxlength="100">' '<input type="hidden" name="test-1-author" id="id_test-1-author">' '<input type="hidden" name="test-1-id" id="id_test-1-id"></p>', ) def test_inline_formsets_with_custom_pk(self): # Test inline formsets where the inline-edited object has a custom # primary key that is not the fk to the parent object. self.maxDiff = 1024 AuthorBooksFormSet2 = inlineformset_factory( Author, BookWithCustomPK, can_delete=False, extra=1, fields="__all__" ) author = Author.objects.create(pk=1, name="Charles Baudelaire") formset = AuthorBooksFormSet2(instance=author) self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_bookwithcustompk_set-0-my_pk">My pk:</label>' '<input id="id_bookwithcustompk_set-0-my_pk" type="number" ' 'name="bookwithcustompk_set-0-my_pk" step="1"></p>' '<p><label for="id_bookwithcustompk_set-0-title">Title:</label>' '<input id="id_bookwithcustompk_set-0-title" type="text" ' 'name="bookwithcustompk_set-0-title" maxlength="100">' '<input type="hidden" name="bookwithcustompk_set-0-author" ' 'value="1" id="id_bookwithcustompk_set-0-author"></p>', ) data = { # The number of forms rendered. "bookwithcustompk_set-TOTAL_FORMS": "1", # The number of forms with initial data. "bookwithcustompk_set-INITIAL_FORMS": "0", # The max number of forms. "bookwithcustompk_set-MAX_NUM_FORMS": "", "bookwithcustompk_set-0-my_pk": "77777", "bookwithcustompk_set-0-title": "Les Fleurs du Mal", } formset = AuthorBooksFormSet2(data, instance=author) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (book1,) = saved self.assertEqual(book1.pk, 77777) book1 = author.bookwithcustompk_set.get() self.assertEqual(book1.title, "Les Fleurs du Mal") def test_inline_formsets_with_multi_table_inheritance(self): # Test inline formsets where the inline-edited object uses multi-table # inheritance, thus has a non AutoField yet auto-created primary key. AuthorBooksFormSet3 = inlineformset_factory( Author, AlternateBook, can_delete=False, extra=1, fields="__all__" ) author = Author.objects.create(pk=1, name="Charles Baudelaire") formset = AuthorBooksFormSet3(instance=author) self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_alternatebook_set-0-title">Title:</label>' '<input id="id_alternatebook_set-0-title" type="text" ' 'name="alternatebook_set-0-title" maxlength="100"></p>' '<p><label for="id_alternatebook_set-0-notes">Notes:</label>' '<input id="id_alternatebook_set-0-notes" type="text" ' 'name="alternatebook_set-0-notes" maxlength="100">' '<input type="hidden" name="alternatebook_set-0-author" value="1" ' 'id="id_alternatebook_set-0-author">' '<input type="hidden" name="alternatebook_set-0-book_ptr" ' 'id="id_alternatebook_set-0-book_ptr"></p>', ) data = { # The number of forms rendered. "alternatebook_set-TOTAL_FORMS": "1", # The number of forms with initial data. "alternatebook_set-INITIAL_FORMS": "0", # The max number of forms. "alternatebook_set-MAX_NUM_FORMS": "", "alternatebook_set-0-title": "Flowers of Evil", "alternatebook_set-0-notes": "English translation of Les Fleurs du Mal", } formset = AuthorBooksFormSet3(data, instance=author) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (book1,) = saved self.assertEqual(book1.title, "Flowers of Evil") self.assertEqual(book1.notes, "English translation of Les Fleurs du Mal") @skipUnlessDBFeature("supports_partially_nullable_unique_constraints") def test_inline_formsets_with_nullable_unique_together(self): # Test inline formsets where the inline-edited object has a # unique_together constraint with a nullable member AuthorBooksFormSet4 = inlineformset_factory( Author, BookWithOptionalAltEditor, can_delete=False, extra=2, fields="__all__", ) author = Author.objects.create(pk=1, name="Charles Baudelaire") data = { # The number of forms rendered. "bookwithoptionalalteditor_set-TOTAL_FORMS": "2", # The number of forms with initial data. "bookwithoptionalalteditor_set-INITIAL_FORMS": "0", # The max number of forms. "bookwithoptionalalteditor_set-MAX_NUM_FORMS": "", "bookwithoptionalalteditor_set-0-author": "1", "bookwithoptionalalteditor_set-0-title": "Les Fleurs du Mal", "bookwithoptionalalteditor_set-1-author": "1", "bookwithoptionalalteditor_set-1-title": "Les Fleurs du Mal", } formset = AuthorBooksFormSet4(data, instance=author) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 2) book1, book2 = saved self.assertEqual(book1.author_id, 1) self.assertEqual(book1.title, "Les Fleurs du Mal") self.assertEqual(book2.author_id, 1) self.assertEqual(book2.title, "Les Fleurs du Mal") def test_inline_formsets_with_custom_save_method(self): AuthorBooksFormSet = inlineformset_factory( Author, Book, can_delete=False, extra=2, fields="__all__" ) author = Author.objects.create(pk=1, name="Charles Baudelaire") book1 = Book.objects.create( pk=1, author=author, title="Les Paradis Artificiels" ) book2 = Book.objects.create(pk=2, author=author, title="Les Fleurs du Mal") book3 = Book.objects.create(pk=3, author=author, title="Flowers of Evil") class PoemForm(forms.ModelForm): def save(self, commit=True): # change the name to "Brooklyn Bridge" just to be a jerk. poem = super().save(commit=False) poem.name = "Brooklyn Bridge" if commit: poem.save() return poem PoemFormSet = inlineformset_factory(Poet, Poem, form=PoemForm, fields="__all__") data = { "poem_set-TOTAL_FORMS": "3", # the number of forms rendered "poem_set-INITIAL_FORMS": "0", # the number of forms with initial data "poem_set-MAX_NUM_FORMS": "", # the max number of forms "poem_set-0-name": "The Cloud in Trousers", "poem_set-1-name": "I", "poem_set-2-name": "", } poet = Poet.objects.create(name="Vladimir Mayakovsky") formset = PoemFormSet(data=data, instance=poet) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 2) poem1, poem2 = saved self.assertEqual(poem1.name, "Brooklyn Bridge") self.assertEqual(poem2.name, "Brooklyn Bridge") # We can provide a custom queryset to our InlineFormSet: custom_qs = Book.objects.order_by("-title") formset = AuthorBooksFormSet(instance=author, queryset=custom_qs) self.assertEqual(len(formset.forms), 5) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_book_set-0-title">Title:</label>' '<input id="id_book_set-0-title" type="text" name="book_set-0-title" ' 'value="Les Paradis Artificiels" maxlength="100">' '<input type="hidden" name="book_set-0-author" value="1" ' 'id="id_book_set-0-author">' '<input type="hidden" name="book_set-0-id" value="1" id="id_book_set-0-id">' "</p>", ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_book_set-1-title">Title:</label>' '<input id="id_book_set-1-title" type="text" name="book_set-1-title" ' 'value="Les Fleurs du Mal" maxlength="100">' '<input type="hidden" name="book_set-1-author" value="1" ' 'id="id_book_set-1-author">' '<input type="hidden" name="book_set-1-id" value="2" id="id_book_set-1-id">' "</p>", ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_book_set-2-title">Title:</label>' '<input id="id_book_set-2-title" type="text" name="book_set-2-title" ' 'value="Flowers of Evil" maxlength="100">' '<input type="hidden" name="book_set-2-author" value="1" ' 'id="id_book_set-2-author">' '<input type="hidden" name="book_set-2-id" value="3" ' 'id="id_book_set-2-id"></p>', ) self.assertHTMLEqual( formset.forms[3].as_p(), '<p><label for="id_book_set-3-title">Title:</label>' '<input id="id_book_set-3-title" type="text" name="book_set-3-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-3-author" value="1" ' 'id="id_book_set-3-author">' '<input type="hidden" name="book_set-3-id" id="id_book_set-3-id"></p>', ) self.assertHTMLEqual( formset.forms[4].as_p(), '<p><label for="id_book_set-4-title">Title:</label>' '<input id="id_book_set-4-title" type="text" name="book_set-4-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-4-author" value="1" ' 'id="id_book_set-4-author">' '<input type="hidden" name="book_set-4-id" id="id_book_set-4-id"></p>', ) data = { "book_set-TOTAL_FORMS": "5", # the number of forms rendered "book_set-INITIAL_FORMS": "3", # the number of forms with initial data "book_set-MAX_NUM_FORMS": "", # the max number of forms "book_set-0-id": str(book1.id), "book_set-0-title": "Les Paradis Artificiels", "book_set-1-id": str(book2.id), "book_set-1-title": "Les Fleurs du Mal", "book_set-2-id": str(book3.id), "book_set-2-title": "Flowers of Evil", "book_set-3-title": "Revue des deux mondes", "book_set-4-title": "", } formset = AuthorBooksFormSet(data, instance=author, queryset=custom_qs) self.assertTrue(formset.is_valid()) custom_qs = Book.objects.filter(title__startswith="F") formset = AuthorBooksFormSet(instance=author, queryset=custom_qs) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_book_set-0-title">Title:</label>' '<input id="id_book_set-0-title" type="text" name="book_set-0-title" ' 'value="Flowers of Evil" maxlength="100">' '<input type="hidden" name="book_set-0-author" value="1" ' 'id="id_book_set-0-author">' '<input type="hidden" name="book_set-0-id" value="3" ' 'id="id_book_set-0-id"></p>', ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_book_set-1-title">Title:</label>' '<input id="id_book_set-1-title" type="text" name="book_set-1-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-1-author" value="1" ' 'id="id_book_set-1-author">' '<input type="hidden" name="book_set-1-id" id="id_book_set-1-id"></p>', ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_book_set-2-title">Title:</label>' '<input id="id_book_set-2-title" type="text" name="book_set-2-title" ' 'maxlength="100">' '<input type="hidden" name="book_set-2-author" value="1" ' 'id="id_book_set-2-author">' '<input type="hidden" name="book_set-2-id" id="id_book_set-2-id"></p>', ) data = { "book_set-TOTAL_FORMS": "3", # the number of forms rendered "book_set-INITIAL_FORMS": "1", # the number of forms with initial data "book_set-MAX_NUM_FORMS": "", # the max number of forms "book_set-0-id": str(book3.id), "book_set-0-title": "Flowers of Evil", "book_set-1-title": "Revue des deux mondes", "book_set-2-title": "", } formset = AuthorBooksFormSet(data, instance=author, queryset=custom_qs) self.assertTrue(formset.is_valid()) def test_inline_formsets_with_custom_save_method_related_instance(self): """ The ModelForm.save() method should be able to access the related object if it exists in the database (#24395). """ class PoemForm2(forms.ModelForm): def save(self, commit=True): poem = super().save(commit=False) poem.name = "%s by %s" % (poem.name, poem.poet.name) if commit: poem.save() return poem PoemFormSet = inlineformset_factory( Poet, Poem, form=PoemForm2, fields="__all__" ) data = { "poem_set-TOTAL_FORMS": "1", "poem_set-INITIAL_FORMS": "0", "poem_set-MAX_NUM_FORMS": "", "poem_set-0-name": "Le Lac", } poet = Poet() formset = PoemFormSet(data=data, instance=poet) self.assertTrue(formset.is_valid()) # The Poet instance is saved after the formset instantiation. This # happens in admin's changeform_view() when adding a new object and # some inlines in the same request. poet.name = "Lamartine" poet.save() poem = formset.save()[0] self.assertEqual(poem.name, "Le Lac by Lamartine") def test_inline_formsets_with_wrong_fk_name(self): """Regression for #23451""" message = "fk_name 'title' is not a ForeignKey to 'model_formsets.Author'." with self.assertRaisesMessage(ValueError, message): inlineformset_factory(Author, Book, fields="__all__", fk_name="title") def test_custom_pk(self): # We need to ensure that it is displayed CustomPrimaryKeyFormSet = modelformset_factory( CustomPrimaryKey, fields="__all__" ) formset = CustomPrimaryKeyFormSet() self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-my_pk">My pk:</label>' '<input id="id_form-0-my_pk" type="text" name="form-0-my_pk" ' 'maxlength="10"></p>' '<p><label for="id_form-0-some_field">Some field:</label>' '<input id="id_form-0-some_field" type="text" name="form-0-some_field" ' 'maxlength="100"></p>', ) # Custom primary keys with ForeignKey, OneToOneField and AutoField ############ place = Place.objects.create(pk=1, name="Giordanos", city="Chicago") FormSet = inlineformset_factory( Place, Owner, extra=2, can_delete=False, fields="__all__" ) formset = FormSet(instance=place) self.assertEqual(len(formset.forms), 2) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_owner_set-0-name">Name:</label>' '<input id="id_owner_set-0-name" type="text" name="owner_set-0-name" ' 'maxlength="100">' '<input type="hidden" name="owner_set-0-place" value="1" ' 'id="id_owner_set-0-place">' '<input type="hidden" name="owner_set-0-auto_id" ' 'id="id_owner_set-0-auto_id"></p>', ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_owner_set-1-name">Name:</label>' '<input id="id_owner_set-1-name" type="text" name="owner_set-1-name" ' 'maxlength="100">' '<input type="hidden" name="owner_set-1-place" value="1" ' 'id="id_owner_set-1-place">' '<input type="hidden" name="owner_set-1-auto_id" ' 'id="id_owner_set-1-auto_id"></p>', ) data = { "owner_set-TOTAL_FORMS": "2", "owner_set-INITIAL_FORMS": "0", "owner_set-MAX_NUM_FORMS": "", "owner_set-0-auto_id": "", "owner_set-0-name": "Joe Perry", "owner_set-1-auto_id": "", "owner_set-1-name": "", } formset = FormSet(data, instance=place) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (owner1,) = saved self.assertEqual(owner1.name, "Joe Perry") self.assertEqual(owner1.place.name, "Giordanos") formset = FormSet(instance=place) self.assertEqual(len(formset.forms), 3) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_owner_set-0-name">Name:</label>' '<input id="id_owner_set-0-name" type="text" name="owner_set-0-name" ' 'value="Joe Perry" maxlength="100">' '<input type="hidden" name="owner_set-0-place" value="1" ' 'id="id_owner_set-0-place">' '<input type="hidden" name="owner_set-0-auto_id" value="%d" ' 'id="id_owner_set-0-auto_id"></p>' % owner1.auto_id, ) self.assertHTMLEqual( formset.forms[1].as_p(), '<p><label for="id_owner_set-1-name">Name:</label>' '<input id="id_owner_set-1-name" type="text" name="owner_set-1-name" ' 'maxlength="100">' '<input type="hidden" name="owner_set-1-place" value="1" ' 'id="id_owner_set-1-place">' '<input type="hidden" name="owner_set-1-auto_id" ' 'id="id_owner_set-1-auto_id"></p>', ) self.assertHTMLEqual( formset.forms[2].as_p(), '<p><label for="id_owner_set-2-name">Name:</label>' '<input id="id_owner_set-2-name" type="text" name="owner_set-2-name" ' 'maxlength="100">' '<input type="hidden" name="owner_set-2-place" value="1" ' 'id="id_owner_set-2-place">' '<input type="hidden" name="owner_set-2-auto_id" ' 'id="id_owner_set-2-auto_id"></p>', ) data = { "owner_set-TOTAL_FORMS": "3", "owner_set-INITIAL_FORMS": "1", "owner_set-MAX_NUM_FORMS": "", "owner_set-0-auto_id": str(owner1.auto_id), "owner_set-0-name": "Joe Perry", "owner_set-1-auto_id": "", "owner_set-1-name": "Jack Berry", "owner_set-2-auto_id": "", "owner_set-2-name": "", } formset = FormSet(data, instance=place) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (owner2,) = saved self.assertEqual(owner2.name, "Jack Berry") self.assertEqual(owner2.place.name, "Giordanos") # A custom primary key that is a ForeignKey or OneToOneField get # rendered for the user to choose. FormSet = modelformset_factory(OwnerProfile, fields="__all__") formset = FormSet() self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_form-0-owner">Owner:</label>' '<select name="form-0-owner" id="id_form-0-owner">' '<option value="" selected>---------</option>' '<option value="%d">Joe Perry at Giordanos</option>' '<option value="%d">Jack Berry at Giordanos</option>' "</select></p>" '<p><label for="id_form-0-age">Age:</label>' '<input type="number" name="form-0-age" id="id_form-0-age" min="0"></p>' % (owner1.auto_id, owner2.auto_id), ) owner1 = Owner.objects.get(name="Joe Perry") FormSet = inlineformset_factory( Owner, OwnerProfile, max_num=1, can_delete=False, fields="__all__" ) self.assertEqual(FormSet.max_num, 1) formset = FormSet(instance=owner1) self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_ownerprofile-0-age">Age:</label>' '<input type="number" name="ownerprofile-0-age" ' 'id="id_ownerprofile-0-age" min="0">' '<input type="hidden" name="ownerprofile-0-owner" value="%d" ' 'id="id_ownerprofile-0-owner"></p>' % owner1.auto_id, ) data = { "ownerprofile-TOTAL_FORMS": "1", "ownerprofile-INITIAL_FORMS": "0", "ownerprofile-MAX_NUM_FORMS": "1", "ownerprofile-0-owner": "", "ownerprofile-0-age": "54", } formset = FormSet(data, instance=owner1) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (profile1,) = saved self.assertEqual(profile1.owner, owner1) self.assertEqual(profile1.age, 54) formset = FormSet(instance=owner1) self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_ownerprofile-0-age">Age:</label>' '<input type="number" name="ownerprofile-0-age" value="54" ' 'id="id_ownerprofile-0-age" min="0">' '<input type="hidden" name="ownerprofile-0-owner" value="%d" ' 'id="id_ownerprofile-0-owner"></p>' % owner1.auto_id, ) data = { "ownerprofile-TOTAL_FORMS": "1", "ownerprofile-INITIAL_FORMS": "1", "ownerprofile-MAX_NUM_FORMS": "1", "ownerprofile-0-owner": str(owner1.auto_id), "ownerprofile-0-age": "55", } formset = FormSet(data, instance=owner1) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (profile1,) = saved self.assertEqual(profile1.owner, owner1) self.assertEqual(profile1.age, 55) def test_unique_true_enforces_max_num_one(self): # ForeignKey with unique=True should enforce max_num=1 place = Place.objects.create(pk=1, name="Giordanos", city="Chicago") FormSet = inlineformset_factory( Place, Location, can_delete=False, fields="__all__" ) self.assertEqual(FormSet.max_num, 1) formset = FormSet(instance=place) self.assertEqual(len(formset.forms), 1) self.assertHTMLEqual( formset.forms[0].as_p(), '<p><label for="id_location_set-0-lat">Lat:</label>' '<input id="id_location_set-0-lat" type="text" name="location_set-0-lat" ' 'maxlength="100"></p>' '<p><label for="id_location_set-0-lon">Lon:</label>' '<input id="id_location_set-0-lon" type="text" name="location_set-0-lon" ' 'maxlength="100">' '<input type="hidden" name="location_set-0-place" value="1" ' 'id="id_location_set-0-place">' '<input type="hidden" name="location_set-0-id" ' 'id="id_location_set-0-id"></p>', ) def test_foreign_keys_in_parents(self): self.assertEqual(type(_get_foreign_key(Restaurant, Owner)), models.ForeignKey) self.assertEqual( type(_get_foreign_key(MexicanRestaurant, Owner)), models.ForeignKey ) def test_unique_validation(self): FormSet = modelformset_factory(Product, fields="__all__", extra=1) data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-slug": "car-red", } formset = FormSet(data) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (product1,) = saved self.assertEqual(product1.slug, "car-red") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-slug": "car-red", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset.errors, [{"slug": ["Product with this Slug already exists."]}] ) def test_modelformset_validate_max_flag(self): # If validate_max is set and max_num is less than TOTAL_FORMS in the # data, then throw an exception. MAX_NUM_FORMS in the data is # irrelevant here (it's output as a hint for the client but its # value in the returned data is not checked) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "2", # should be ignored "form-0-price": "12.00", "form-0-quantity": "1", "form-1-price": "24.00", "form-1-quantity": "2", } FormSet = modelformset_factory( Price, fields="__all__", extra=1, max_num=1, validate_max=True ) formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual(formset.non_form_errors(), ["Please submit at most 1 form."]) # Now test the same thing without the validate_max flag to ensure # default behavior is unchanged FormSet = modelformset_factory(Price, fields="__all__", extra=1, max_num=1) formset = FormSet(data) self.assertTrue(formset.is_valid()) def test_modelformset_min_num_equals_max_num_less_than(self): data = { "form-TOTAL_FORMS": "3", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "2", "form-0-slug": "car-red", "form-1-slug": "car-blue", "form-2-slug": "car-black", } FormSet = modelformset_factory( Product, fields="__all__", extra=1, max_num=2, validate_max=True, min_num=2, validate_min=True, ) formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual(formset.non_form_errors(), ["Please submit at most 2 forms."]) def test_modelformset_min_num_equals_max_num_more_than(self): data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "2", "form-0-slug": "car-red", } FormSet = modelformset_factory( Product, fields="__all__", extra=1, max_num=2, validate_max=True, min_num=2, validate_min=True, ) formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual(formset.non_form_errors(), ["Please submit at least 2 forms."]) def test_unique_together_validation(self): FormSet = modelformset_factory(Price, fields="__all__", extra=1) data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-price": "12.00", "form-0-quantity": "1", } formset = FormSet(data) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (price1,) = saved self.assertEqual(price1.price, Decimal("12.00")) self.assertEqual(price1.quantity, 1) data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-price": "12.00", "form-0-quantity": "1", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset.errors, [{"__all__": ["Price with this Price and Quantity already exists."]}], ) def test_unique_together_with_inlineformset_factory(self): # Also see bug #8882. repository = Repository.objects.create(name="Test Repo") FormSet = inlineformset_factory(Repository, Revision, extra=1, fields="__all__") data = { "revision_set-TOTAL_FORMS": "1", "revision_set-INITIAL_FORMS": "0", "revision_set-MAX_NUM_FORMS": "", "revision_set-0-repository": repository.pk, "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76", "revision_set-0-DELETE": "", } formset = FormSet(data, instance=repository) self.assertTrue(formset.is_valid()) saved = formset.save() self.assertEqual(len(saved), 1) (revision1,) = saved self.assertEqual(revision1.repository, repository) self.assertEqual(revision1.revision, "146239817507f148d448db38840db7c3cbf47c76") # attempt to save the same revision against the same repo. data = { "revision_set-TOTAL_FORMS": "1", "revision_set-INITIAL_FORMS": "0", "revision_set-MAX_NUM_FORMS": "", "revision_set-0-repository": repository.pk, "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76", "revision_set-0-DELETE": "", } formset = FormSet(data, instance=repository) self.assertFalse(formset.is_valid()) self.assertEqual( formset.errors, [ { "__all__": [ "Revision with this Repository and Revision already exists." ] } ], ) # unique_together with inlineformset_factory with overridden form fields # Also see #9494 FormSet = inlineformset_factory( Repository, Revision, fields=("revision",), extra=1 ) data = { "revision_set-TOTAL_FORMS": "1", "revision_set-INITIAL_FORMS": "0", "revision_set-MAX_NUM_FORMS": "", "revision_set-0-repository": repository.pk, "revision_set-0-revision": "146239817507f148d448db38840db7c3cbf47c76", "revision_set-0-DELETE": "", } formset = FormSet(data, instance=repository) self.assertFalse(formset.is_valid()) def test_callable_defaults(self): # Use of callable defaults (see bug #7975). person = Person.objects.create(name="Ringo") FormSet = inlineformset_factory( Person, Membership, can_delete=False, extra=1, fields="__all__" ) formset = FormSet(instance=person) # Django will render a hidden field for model fields that have a callable # default. This is required to ensure the value is tested for change correctly # when determine what extra forms have changed to save. self.assertEqual(len(formset.forms), 1) # this formset only has one form form = formset.forms[0] now = form.fields["date_joined"].initial() result = form.as_p() result = re.sub( r"[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?", "__DATETIME__", result, ) self.assertHTMLEqual( result, '<p><label for="id_membership_set-0-date_joined">Date joined:</label>' '<input type="text" name="membership_set-0-date_joined" ' 'value="__DATETIME__" id="id_membership_set-0-date_joined">' '<input type="hidden" name="initial-membership_set-0-date_joined" ' 'value="__DATETIME__" ' 'id="initial-membership_set-0-id_membership_set-0-date_joined"></p>' '<p><label for="id_membership_set-0-karma">Karma:</label>' '<input type="number" name="membership_set-0-karma" ' 'id="id_membership_set-0-karma">' '<input type="hidden" name="membership_set-0-person" value="%d" ' 'id="id_membership_set-0-person">' '<input type="hidden" name="membership_set-0-id" ' 'id="id_membership_set-0-id"></p>' % person.id, ) # test for validation with callable defaults. Validations rely on hidden fields data = { "membership_set-TOTAL_FORMS": "1", "membership_set-INITIAL_FORMS": "0", "membership_set-MAX_NUM_FORMS": "", "membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"), "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"), "membership_set-0-karma": "", } formset = FormSet(data, instance=person) self.assertTrue(formset.is_valid()) # now test for when the data changes one_day_later = now + datetime.timedelta(days=1) filled_data = { "membership_set-TOTAL_FORMS": "1", "membership_set-INITIAL_FORMS": "0", "membership_set-MAX_NUM_FORMS": "", "membership_set-0-date_joined": one_day_later.strftime("%Y-%m-%d %H:%M:%S"), "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"), "membership_set-0-karma": "", } formset = FormSet(filled_data, instance=person) self.assertFalse(formset.is_valid()) # now test with split datetime fields class MembershipForm(forms.ModelForm): date_joined = forms.SplitDateTimeField(initial=now) class Meta: model = Membership fields = "__all__" def __init__(self, **kwargs): super().__init__(**kwargs) self.fields["date_joined"].widget = forms.SplitDateTimeWidget() FormSet = inlineformset_factory( Person, Membership, form=MembershipForm, can_delete=False, extra=1, fields="__all__", ) data = { "membership_set-TOTAL_FORMS": "1", "membership_set-INITIAL_FORMS": "0", "membership_set-MAX_NUM_FORMS": "", "membership_set-0-date_joined_0": now.strftime("%Y-%m-%d"), "membership_set-0-date_joined_1": now.strftime("%H:%M:%S"), "initial-membership_set-0-date_joined": now.strftime("%Y-%m-%d %H:%M:%S"), "membership_set-0-karma": "", } formset = FormSet(data, instance=person) self.assertTrue(formset.is_valid()) def test_inlineformset_factory_with_null_fk(self): # inlineformset_factory tests with fk having null=True. see #9462. # create some data that will exhibit the issue team = Team.objects.create(name="Red Vipers") Player(name="Timmy").save() Player(name="Bobby", team=team).save() PlayerInlineFormSet = inlineformset_factory(Team, Player, fields="__all__") formset = PlayerInlineFormSet() self.assertQuerysetEqual(formset.get_queryset(), []) formset = PlayerInlineFormSet(instance=team) players = formset.get_queryset() self.assertEqual(len(players), 1) (player1,) = players self.assertEqual(player1.team, team) self.assertEqual(player1.name, "Bobby") def test_inlineformset_with_arrayfield(self): class SimpleArrayField(forms.CharField): """A proxy for django.contrib.postgres.forms.SimpleArrayField.""" def to_python(self, value): value = super().to_python(value) return value.split(",") if value else [] class BookForm(forms.ModelForm): title = SimpleArrayField() class Meta: model = Book fields = ("title",) BookFormSet = inlineformset_factory(Author, Book, form=BookForm) data = { "book_set-TOTAL_FORMS": "3", "book_set-INITIAL_FORMS": "0", "book_set-MAX_NUM_FORMS": "", "book_set-0-title": "test1,test2", "book_set-1-title": "test1,test2", "book_set-2-title": "test3,test4", } author = Author.objects.create(name="test") formset = BookFormSet(data, instance=author) self.assertEqual( formset.errors, [{}, {"__all__": ["Please correct the duplicate values below."]}, {}], ) def test_model_formset_with_custom_pk(self): # a formset for a Model that has a custom primary key that still needs to be # added to the formset automatically FormSet = modelformset_factory( ClassyMexicanRestaurant, fields=["tacos_are_yummy"] ) self.assertEqual( sorted(FormSet().forms[0].fields), ["tacos_are_yummy", "the_restaurant"] ) def test_model_formset_with_initial_model_instance(self): # has_changed should compare model instance and primary key # see #18898 FormSet = modelformset_factory(Poem, fields="__all__") john_milton = Poet(name="John Milton") john_milton.save() data = { "form-TOTAL_FORMS": 1, "form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": "", "form-0-name": "", "form-0-poet": str(john_milton.id), } formset = FormSet(initial=[{"poet": john_milton}], data=data) self.assertFalse(formset.extra_forms[0].has_changed()) def test_model_formset_with_initial_queryset(self): # has_changed should work with queryset and list of pk's # see #18898 FormSet = modelformset_factory(AuthorMeeting, fields="__all__") Author.objects.create(pk=1, name="Charles Baudelaire") data = { "form-TOTAL_FORMS": 1, "form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": "", "form-0-name": "", "form-0-created": "", "form-0-authors": list(Author.objects.values_list("id", flat=True)), } formset = FormSet(initial=[{"authors": Author.objects.all()}], data=data) self.assertFalse(formset.extra_forms[0].has_changed()) def test_prevent_duplicates_from_with_the_same_formset(self): FormSet = modelformset_factory(Product, fields="__all__", extra=2) data = { "form-TOTAL_FORMS": 2, "form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": "", "form-0-slug": "red_car", "form-1-slug": "red_car", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, ["Please correct the duplicate data for slug."] ) FormSet = modelformset_factory(Price, fields="__all__", extra=2) data = { "form-TOTAL_FORMS": 2, "form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": "", "form-0-price": "25", "form-0-quantity": "7", "form-1-price": "25", "form-1-quantity": "7", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, [ "Please correct the duplicate data for price and quantity, which must " "be unique." ], ) # Only the price field is specified, this should skip any unique # checks since the unique_together is not fulfilled. This will fail # with a KeyError if broken. FormSet = modelformset_factory(Price, fields=("price",), extra=2) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-price": "24", "form-1-price": "24", } formset = FormSet(data) self.assertTrue(formset.is_valid()) FormSet = inlineformset_factory(Author, Book, extra=0, fields="__all__") author = Author.objects.create(pk=1, name="Charles Baudelaire") Book.objects.create(pk=1, author=author, title="Les Paradis Artificiels") Book.objects.create(pk=2, author=author, title="Les Fleurs du Mal") Book.objects.create(pk=3, author=author, title="Flowers of Evil") book_ids = author.book_set.order_by("id").values_list("id", flat=True) data = { "book_set-TOTAL_FORMS": "2", "book_set-INITIAL_FORMS": "2", "book_set-MAX_NUM_FORMS": "", "book_set-0-title": "The 2008 Election", "book_set-0-author": str(author.id), "book_set-0-id": str(book_ids[0]), "book_set-1-title": "The 2008 Election", "book_set-1-author": str(author.id), "book_set-1-id": str(book_ids[1]), } formset = FormSet(data=data, instance=author) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, ["Please correct the duplicate data for title."] ) self.assertEqual( formset.errors, [{}, {"__all__": ["Please correct the duplicate values below."]}], ) FormSet = modelformset_factory(Post, fields="__all__", extra=2) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-title": "blah", "form-0-slug": "Morning", "form-0-subtitle": "foo", "form-0-posted": "2009-01-01", "form-1-title": "blah", "form-1-slug": "Morning in Prague", "form-1-subtitle": "rawr", "form-1-posted": "2009-01-01", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, [ "Please correct the duplicate data for title which must be unique for " "the date in posted." ], ) self.assertEqual( formset.errors, [{}, {"__all__": ["Please correct the duplicate values below."]}], ) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-title": "foo", "form-0-slug": "Morning in Prague", "form-0-subtitle": "foo", "form-0-posted": "2009-01-01", "form-1-title": "blah", "form-1-slug": "Morning in Prague", "form-1-subtitle": "rawr", "form-1-posted": "2009-08-02", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, [ "Please correct the duplicate data for slug which must be unique for " "the year in posted." ], ) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "", "form-0-title": "foo", "form-0-slug": "Morning in Prague", "form-0-subtitle": "rawr", "form-0-posted": "2008-08-01", "form-1-title": "blah", "form-1-slug": "Prague", "form-1-subtitle": "rawr", "form-1-posted": "2009-08-02", } formset = FormSet(data) self.assertFalse(formset.is_valid()) self.assertEqual( formset._non_form_errors, [ "Please correct the duplicate data for subtitle which must be unique " "for the month in posted." ], ) def test_prevent_change_outer_model_and_create_invalid_data(self): author = Author.objects.create(name="Charles") other_author = Author.objects.create(name="Walt") AuthorFormSet = modelformset_factory(Author, fields="__all__") data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "2", "form-MAX_NUM_FORMS": "", "form-0-id": str(author.id), "form-0-name": "Charles", "form-1-id": str(other_author.id), # A model not in the formset's queryset. "form-1-name": "Changed name", } # This formset is only for Walt Whitman and shouldn't accept data for # other_author. formset = AuthorFormSet( data=data, queryset=Author.objects.filter(id__in=(author.id,)) ) self.assertTrue(formset.is_valid()) formset.save() # The name of other_author shouldn't be changed and new models aren't # created. self.assertSequenceEqual(Author.objects.all(), [author, other_author]) def test_validation_without_id(self): AuthorFormSet = modelformset_factory(Author, fields="__all__") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "", "form-0-name": "Charles", } formset = AuthorFormSet(data) self.assertEqual( formset.errors, [{"id": ["This field is required."]}], ) def test_validation_with_child_model_without_id(self): BetterAuthorFormSet = modelformset_factory(BetterAuthor, fields="__all__") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "", "form-0-name": "Charles", "form-0-write_speed": "10", } formset = BetterAuthorFormSet(data) self.assertEqual( formset.errors, [{"author_ptr": ["This field is required."]}], ) def test_validation_with_invalid_id(self): AuthorFormSet = modelformset_factory(Author, fields="__all__") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "", "form-0-id": "abc", "form-0-name": "Charles", } formset = AuthorFormSet(data) self.assertEqual( formset.errors, [ { "id": [ "Select a valid choice. That choice is not one of the " "available choices." ] } ], ) def test_validation_with_nonexistent_id(self): AuthorFormSet = modelformset_factory(Author, fields="__all__") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "", "form-0-id": "12345", "form-0-name": "Charles", } formset = AuthorFormSet(data) self.assertEqual( formset.errors, [ { "id": [ "Select a valid choice. That choice is not one of the " "available choices." ] } ], ) def test_initial_form_count_empty_data(self): AuthorFormSet = modelformset_factory(Author, fields="__all__") formset = AuthorFormSet({}) self.assertEqual(formset.initial_form_count(), 0) def test_edit_only(self): charles = Author.objects.create(name="Charles Baudelaire") AuthorFormSet = modelformset_factory(Author, fields="__all__", edit_only=True) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "0", "form-0-name": "Arthur Rimbaud", "form-1-name": "Walt Whitman", } formset = AuthorFormSet(data) self.assertIs(formset.is_valid(), True) formset.save() self.assertSequenceEqual(Author.objects.all(), [charles]) data = { "form-TOTAL_FORMS": "2", "form-INITIAL_FORMS": "1", "form-MAX_NUM_FORMS": "0", "form-0-id": charles.pk, "form-0-name": "Arthur Rimbaud", "form-1-name": "Walt Whitman", } formset = AuthorFormSet(data) self.assertIs(formset.is_valid(), True) formset.save() charles.refresh_from_db() self.assertEqual(charles.name, "Arthur Rimbaud") self.assertSequenceEqual(Author.objects.all(), [charles]) def test_edit_only_inlineformset_factory(self): charles = Author.objects.create(name="Charles Baudelaire") book = Book.objects.create(author=charles, title="Les Paradis Artificiels") AuthorFormSet = inlineformset_factory( Author, Book, can_delete=False, fields="__all__", edit_only=True, ) data = { "book_set-TOTAL_FORMS": "4", "book_set-INITIAL_FORMS": "1", "book_set-MAX_NUM_FORMS": "0", "book_set-0-id": book.pk, "book_set-0-title": "Les Fleurs du Mal", "book_set-0-author": charles.pk, "book_set-1-title": "Flowers of Evil", "book_set-1-author": charles.pk, } formset = AuthorFormSet(data, instance=charles) self.assertIs(formset.is_valid(), True) formset.save() book.refresh_from_db() self.assertEqual(book.title, "Les Fleurs du Mal") self.assertSequenceEqual(Book.objects.all(), [book]) def test_edit_only_object_outside_of_queryset(self): charles = Author.objects.create(name="Charles Baudelaire") walt = Author.objects.create(name="Walt Whitman") data = { "form-TOTAL_FORMS": "1", "form-INITIAL_FORMS": "1", "form-0-id": walt.pk, "form-0-name": "Parth Patil", } AuthorFormSet = modelformset_factory(Author, fields="__all__", edit_only=True) formset = AuthorFormSet(data, queryset=Author.objects.filter(pk=charles.pk)) self.assertIs(formset.is_valid(), True) formset.save() self.assertCountEqual(Author.objects.all(), [charles, walt]) class TestModelFormsetOverridesTroughFormMeta(TestCase): def test_modelformset_factory_widgets(self): widgets = {"name": forms.TextInput(attrs={"class": "poet"})} PoetFormSet = modelformset_factory(Poet, fields="__all__", widgets=widgets) form = PoetFormSet.form() self.assertHTMLEqual( str(form["name"]), '<input id="id_name" maxlength="100" type="text" class="poet" name="name" ' "required>", ) def test_inlineformset_factory_widgets(self): widgets = {"title": forms.TextInput(attrs={"class": "book"})} BookFormSet = inlineformset_factory( Author, Book, widgets=widgets, fields="__all__" ) form = BookFormSet.form() self.assertHTMLEqual( str(form["title"]), '<input class="book" id="id_title" maxlength="100" name="title" ' 'type="text" required>', ) def test_modelformset_factory_labels_overrides(self): BookFormSet = modelformset_factory( Book, fields="__all__", labels={"title": "Name"} ) form = BookFormSet.form() self.assertHTMLEqual( form["title"].label_tag(), '<label for="id_title">Name:</label>' ) self.assertHTMLEqual( form["title"].legend_tag(), '<legend for="id_title">Name:</legend>', ) def test_inlineformset_factory_labels_overrides(self): BookFormSet = inlineformset_factory( Author, Book, fields="__all__", labels={"title": "Name"} ) form = BookFormSet.form() self.assertHTMLEqual( form["title"].label_tag(), '<label for="id_title">Name:</label>' ) self.assertHTMLEqual( form["title"].legend_tag(), '<legend for="id_title">Name:</legend>', ) def test_modelformset_factory_help_text_overrides(self): BookFormSet = modelformset_factory( Book, fields="__all__", help_texts={"title": "Choose carefully."} ) form = BookFormSet.form() self.assertEqual(form["title"].help_text, "Choose carefully.") def test_inlineformset_factory_help_text_overrides(self): BookFormSet = inlineformset_factory( Author, Book, fields="__all__", help_texts={"title": "Choose carefully."} ) form = BookFormSet.form() self.assertEqual(form["title"].help_text, "Choose carefully.") def test_modelformset_factory_error_messages_overrides(self): author = Author.objects.create(pk=1, name="Charles Baudelaire") BookFormSet = modelformset_factory( Book, fields="__all__", error_messages={"title": {"max_length": "Title too long!!"}}, ) form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id}) form.full_clean() self.assertEqual(form.errors, {"title": ["Title too long!!"]}) def test_inlineformset_factory_error_messages_overrides(self): author = Author.objects.create(pk=1, name="Charles Baudelaire") BookFormSet = inlineformset_factory( Author, Book, fields="__all__", error_messages={"title": {"max_length": "Title too long!!"}}, ) form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id}) form.full_clean() self.assertEqual(form.errors, {"title": ["Title too long!!"]}) def test_modelformset_factory_field_class_overrides(self): author = Author.objects.create(pk=1, name="Charles Baudelaire") BookFormSet = modelformset_factory( Book, fields="__all__", field_classes={ "title": forms.SlugField, }, ) form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id}) self.assertIs(Book._meta.get_field("title").__class__, models.CharField) self.assertIsInstance(form.fields["title"], forms.SlugField) def test_inlineformset_factory_field_class_overrides(self): author = Author.objects.create(pk=1, name="Charles Baudelaire") BookFormSet = inlineformset_factory( Author, Book, fields="__all__", field_classes={ "title": forms.SlugField, }, ) form = BookFormSet.form(data={"title": "Foo " * 30, "author": author.id}) self.assertIs(Book._meta.get_field("title").__class__, models.CharField) self.assertIsInstance(form.fields["title"], forms.SlugField) def test_modelformset_factory_absolute_max(self): AuthorFormSet = modelformset_factory( Author, fields="__all__", absolute_max=1500 ) data = { "form-TOTAL_FORMS": "1501", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "0", } formset = AuthorFormSet(data=data) self.assertIs(formset.is_valid(), False) self.assertEqual(len(formset.forms), 1500) self.assertEqual( formset.non_form_errors(), ["Please submit at most 1000 forms."], ) def test_modelformset_factory_absolute_max_with_max_num(self): AuthorFormSet = modelformset_factory( Author, fields="__all__", max_num=20, absolute_max=100, ) data = { "form-TOTAL_FORMS": "101", "form-INITIAL_FORMS": "0", "form-MAX_NUM_FORMS": "0", } formset = AuthorFormSet(data=data) self.assertIs(formset.is_valid(), False) self.assertEqual(len(formset.forms), 100) self.assertEqual( formset.non_form_errors(), ["Please submit at most 20 forms."], ) def test_inlineformset_factory_absolute_max(self): author = Author.objects.create(name="Charles Baudelaire") BookFormSet = inlineformset_factory( Author, Book, fields="__all__", absolute_max=1500, ) data = { "book_set-TOTAL_FORMS": "1501", "book_set-INITIAL_FORMS": "0", "book_set-MAX_NUM_FORMS": "0", } formset = BookFormSet(data, instance=author) self.assertIs(formset.is_valid(), False) self.assertEqual(len(formset.forms), 1500) self.assertEqual( formset.non_form_errors(), ["Please submit at most 1000 forms."], ) def test_inlineformset_factory_absolute_max_with_max_num(self): author = Author.objects.create(name="Charles Baudelaire") BookFormSet = inlineformset_factory( Author, Book, fields="__all__", max_num=20, absolute_max=100, ) data = { "book_set-TOTAL_FORMS": "101", "book_set-INITIAL_FORMS": "0", "book_set-MAX_NUM_FORMS": "0", } formset = BookFormSet(data, instance=author) self.assertIs(formset.is_valid(), False) self.assertEqual(len(formset.forms), 100) self.assertEqual( formset.non_form_errors(), ["Please submit at most 20 forms."], ) def test_modelformset_factory_can_delete_extra(self): AuthorFormSet = modelformset_factory( Author, fields="__all__", can_delete=True, can_delete_extra=True, extra=2, ) formset = AuthorFormSet() self.assertEqual(len(formset), 2) self.assertIn("DELETE", formset.forms[0].fields) self.assertIn("DELETE", formset.forms[1].fields) def test_modelformset_factory_disable_delete_extra(self): AuthorFormSet = modelformset_factory( Author, fields="__all__", can_delete=True, can_delete_extra=False, extra=2, ) formset = AuthorFormSet() self.assertEqual(len(formset), 2) self.assertNotIn("DELETE", formset.forms[0].fields) self.assertNotIn("DELETE", formset.forms[1].fields) def test_inlineformset_factory_can_delete_extra(self): BookFormSet = inlineformset_factory( Author, Book, fields="__all__", can_delete=True, can_delete_extra=True, extra=2, ) formset = BookFormSet() self.assertEqual(len(formset), 2) self.assertIn("DELETE", formset.forms[0].fields) self.assertIn("DELETE", formset.forms[1].fields) def test_inlineformset_factory_can_not_delete_extra(self): BookFormSet = inlineformset_factory( Author, Book, fields="__all__", can_delete=True, can_delete_extra=False, extra=2, ) formset = BookFormSet() self.assertEqual(len(formset), 2) self.assertNotIn("DELETE", formset.forms[0].fields) self.assertNotIn("DELETE", formset.forms[1].fields) def test_inlineformset_factory_passes_renderer(self): from django.forms.renderers import Jinja2 renderer = Jinja2() BookFormSet = inlineformset_factory( Author, Book, fields="__all__", renderer=renderer, ) formset = BookFormSet() self.assertEqual(formset.renderer, renderer) def test_modelformset_factory_passes_renderer(self): from django.forms.renderers import Jinja2 renderer = Jinja2() BookFormSet = modelformset_factory(Author, fields="__all__", renderer=renderer) formset = BookFormSet() self.assertEqual(formset.renderer, renderer)
5e953d52e8729ffc406debadc26ed22ec1890fc23a212987cbde6de44a8743e7
import datetime import uuid from django.db import models class Author(models.Model): name = models.CharField(max_length=100) class Meta: ordering = ("name",) def __str__(self): return self.name class BetterAuthor(Author): write_speed = models.IntegerField() class Book(models.Model): author = models.ForeignKey(Author, models.CASCADE) title = models.CharField(max_length=100) class Meta: unique_together = (("author", "title"),) ordering = ["id"] def __str__(self): return self.title def clean(self): # Ensure author is always accessible in clean method assert self.author.name is not None class BookWithCustomPK(models.Model): my_pk = models.DecimalField(max_digits=5, decimal_places=0, primary_key=True) author = models.ForeignKey(Author, models.CASCADE) title = models.CharField(max_length=100) def __str__(self): return "%s: %s" % (self.my_pk, self.title) class Editor(models.Model): name = models.CharField(max_length=100) class BookWithOptionalAltEditor(models.Model): author = models.ForeignKey(Author, models.CASCADE) # Optional secondary author alt_editor = models.ForeignKey(Editor, models.SET_NULL, blank=True, null=True) title = models.CharField(max_length=100) class Meta: unique_together = (("author", "title", "alt_editor"),) def __str__(self): return self.title class AlternateBook(Book): notes = models.CharField(max_length=100) def __str__(self): return "%s - %s" % (self.title, self.notes) class AuthorMeeting(models.Model): name = models.CharField(max_length=100) authors = models.ManyToManyField(Author) created = models.DateField(editable=False) def __str__(self): return self.name class CustomPrimaryKey(models.Model): my_pk = models.CharField(max_length=10, primary_key=True) some_field = models.CharField(max_length=100) # models for inheritance tests. class Place(models.Model): name = models.CharField(max_length=50) city = models.CharField(max_length=50) def __str__(self): return self.name class Owner(models.Model): auto_id = models.AutoField(primary_key=True) name = models.CharField(max_length=100) place = models.ForeignKey(Place, models.CASCADE) def __str__(self): return "%s at %s" % (self.name, self.place) class Location(models.Model): place = models.ForeignKey(Place, models.CASCADE, unique=True) # this is purely for testing the data doesn't matter here :) lat = models.CharField(max_length=100) lon = models.CharField(max_length=100) class OwnerProfile(models.Model): owner = models.OneToOneField(Owner, models.CASCADE, primary_key=True) age = models.PositiveIntegerField() def __str__(self): return "%s is %d" % (self.owner.name, self.age) class Restaurant(Place): serves_pizza = models.BooleanField(default=False) class Product(models.Model): slug = models.SlugField(unique=True) def __str__(self): return self.slug class Price(models.Model): price = models.DecimalField(max_digits=10, decimal_places=2) quantity = models.PositiveIntegerField() class Meta: unique_together = (("price", "quantity"),) def __str__(self): return "%s for %s" % (self.quantity, self.price) class MexicanRestaurant(Restaurant): serves_tacos = models.BooleanField(default=False) class ClassyMexicanRestaurant(MexicanRestaurant): the_restaurant = models.OneToOneField( MexicanRestaurant, models.CASCADE, parent_link=True, primary_key=True ) tacos_are_yummy = models.BooleanField(default=False) # models for testing unique_together validation when a fk is involved and # using inlineformset_factory. class Repository(models.Model): name = models.CharField(max_length=25) def __str__(self): return self.name class Revision(models.Model): repository = models.ForeignKey(Repository, models.CASCADE) revision = models.CharField(max_length=40) class Meta: unique_together = (("repository", "revision"),) def __str__(self): return "%s (%s)" % (self.revision, str(self.repository)) # models for testing callable defaults (see bug #7975). If you define a model # with a callable default value, you cannot rely on the initial value in a # form. class Person(models.Model): name = models.CharField(max_length=128) class Membership(models.Model): person = models.ForeignKey(Person, models.CASCADE) date_joined = models.DateTimeField(default=datetime.datetime.now) karma = models.IntegerField() # models for testing a null=True fk to a parent class Team(models.Model): name = models.CharField(max_length=100) class Player(models.Model): team = models.ForeignKey(Team, models.SET_NULL, null=True) name = models.CharField(max_length=100) def __str__(self): return self.name # Models for testing custom ModelForm save methods in formsets and inline formsets class Poet(models.Model): name = models.CharField(max_length=100) def __str__(self): return self.name class Poem(models.Model): poet = models.ForeignKey(Poet, models.CASCADE) name = models.CharField(max_length=100) def __str__(self): return self.name class Post(models.Model): title = models.CharField(max_length=50, unique_for_date="posted", blank=True) slug = models.CharField(max_length=50, unique_for_year="posted", blank=True) subtitle = models.CharField(max_length=50, unique_for_month="posted", blank=True) posted = models.DateField() def __str__(self): return self.title # Models for testing UUID primary keys class UUIDPKParent(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) name = models.CharField(max_length=255) class UUIDPKChild(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) name = models.CharField(max_length=255) parent = models.ForeignKey(UUIDPKParent, models.CASCADE) class ChildWithEditablePK(models.Model): name = models.CharField(max_length=255, primary_key=True) parent = models.ForeignKey(UUIDPKParent, models.CASCADE) class AutoPKChildOfUUIDPKParent(models.Model): name = models.CharField(max_length=255) parent = models.ForeignKey(UUIDPKParent, models.CASCADE) class AutoPKParent(models.Model): name = models.CharField(max_length=255) class UUIDPKChildOfAutoPKParent(models.Model): uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) name = models.CharField(max_length=255) parent = models.ForeignKey(AutoPKParent, models.CASCADE) class ParentWithUUIDAlternateKey(models.Model): uuid = models.UUIDField(unique=True, default=uuid.uuid4, editable=False) name = models.CharField(max_length=50) class ChildRelatedViaAK(models.Model): name = models.CharField(max_length=255) parent = models.ForeignKey( ParentWithUUIDAlternateKey, models.CASCADE, to_field="uuid" )
88d4284844bbd01a695eb9b6aceeac758d0af6b4f66fae68bc5cdd52c8c20ba1
from django.forms.models import inlineformset_factory from django.test import TestCase from .models import ( AutoPKChildOfUUIDPKParent, AutoPKParent, ChildRelatedViaAK, ChildWithEditablePK, ParentWithUUIDAlternateKey, UUIDPKChild, UUIDPKChildOfAutoPKParent, UUIDPKParent, ) class InlineFormsetTests(TestCase): def test_inlineformset_factory_nulls_default_pks(self): """ #24377 - If we're adding a new object, a parent's auto-generated pk from the model field default should be ignored as it's regenerated on the save request. Tests the case where both the parent and child have a UUID primary key. """ FormSet = inlineformset_factory(UUIDPKParent, UUIDPKChild, fields="__all__") formset = FormSet() self.assertIsNone(formset.forms[0].fields["parent"].initial) def test_inlineformset_factory_ignores_default_pks_on_submit(self): """ #24377 - Inlines with a model field default should ignore that default value to avoid triggering validation on empty forms. """ FormSet = inlineformset_factory(UUIDPKParent, UUIDPKChild, fields="__all__") formset = FormSet( { "uuidpkchild_set-TOTAL_FORMS": 3, "uuidpkchild_set-INITIAL_FORMS": 0, "uuidpkchild_set-MAX_NUM_FORMS": "", "uuidpkchild_set-0-name": "Foo", "uuidpkchild_set-1-name": "", "uuidpkchild_set-2-name": "", } ) self.assertTrue(formset.is_valid()) def test_inlineformset_factory_nulls_default_pks_uuid_parent_auto_child(self): """ #24958 - Variant of test_inlineformset_factory_nulls_default_pks for the case of a parent object with a UUID primary key and a child object with an AutoField primary key. """ FormSet = inlineformset_factory( UUIDPKParent, AutoPKChildOfUUIDPKParent, fields="__all__" ) formset = FormSet() self.assertIsNone(formset.forms[0].fields["parent"].initial) def test_inlineformset_factory_nulls_default_pks_auto_parent_uuid_child(self): """ #24958 - Variant of test_inlineformset_factory_nulls_default_pks for the case of a parent object with an AutoField primary key and a child object with a UUID primary key. """ FormSet = inlineformset_factory( AutoPKParent, UUIDPKChildOfAutoPKParent, fields="__all__" ) formset = FormSet() self.assertIsNone(formset.forms[0].fields["parent"].initial) def test_inlineformset_factory_nulls_default_pks_child_editable_pk(self): """ #24958 - Variant of test_inlineformset_factory_nulls_default_pks for the case of a parent object with a UUID primary key and a child object with an editable natural key for a primary key. """ FormSet = inlineformset_factory( UUIDPKParent, ChildWithEditablePK, fields="__all__" ) formset = FormSet() self.assertIsNone(formset.forms[0].fields["parent"].initial) def test_inlineformset_factory_nulls_default_pks_alternate_key_relation(self): """ #24958 - Variant of test_inlineformset_factory_nulls_default_pks for the case of a parent object with a UUID alternate key and a child object that relates to that alternate key. """ FormSet = inlineformset_factory( ParentWithUUIDAlternateKey, ChildRelatedViaAK, fields="__all__" ) formset = FormSet() self.assertIsNone(formset.forms[0].fields["parent"].initial)
1832e9520845b5b3dad840a5e4b3eb8d7155753ec2355967e3ecd3c7951434a0
from django.test import TestCase from .models import Parent class MutuallyReferentialTests(TestCase): def test_mutually_referential(self): # Create a Parent q = Parent(name="Elizabeth") q.save() # Create some children c = q.child_set.create(name="Charles") q.child_set.create(name="Edward") # Set the best child # No assertion require here; if basic assignment and # deletion works, the test passes. q.bestchild = c q.save() q.delete()
b604c6f25ec7e22f3b1ee9bfe6f860af14efedf5c585bcbf48299feafa64c497
""" Mutually referential many-to-one relationships Strings can be used instead of model literals to set up "lazy" relations. """ from django.db import models class Parent(models.Model): name = models.CharField(max_length=100) # Use a simple string for forward declarations. bestchild = models.ForeignKey( "Child", models.SET_NULL, null=True, related_name="favored_by" ) class Child(models.Model): name = models.CharField(max_length=100) # You can also explicitly specify the related app. parent = models.ForeignKey("mutually_referential.Parent", models.CASCADE)
0121a8a19f4ca0fe869daa6d1c044e87ba5938b743d84c21bf441c345590cc64
import datetime from copy import deepcopy from django.core.exceptions import FieldError, MultipleObjectsReturned from django.db import IntegrityError, models, transaction from django.test import TestCase from django.utils.translation import gettext_lazy from .models import ( Article, Category, Child, ChildNullableParent, ChildStringPrimaryKeyParent, City, Country, District, First, Parent, ParentStringPrimaryKey, Record, Relation, Reporter, School, Student, Third, ToFieldChild, ) class ManyToOneTests(TestCase): @classmethod def setUpTestData(cls): # Create a few Reporters. cls.r = Reporter(first_name="John", last_name="Smith", email="[email protected]") cls.r.save() cls.r2 = Reporter( first_name="Paul", last_name="Jones", email="[email protected]" ) cls.r2.save() # Create an Article. cls.a = Article( headline="This is a test", pub_date=datetime.date(2005, 7, 27), reporter=cls.r, ) cls.a.save() def test_get(self): # Article objects have access to their related Reporter objects. r = self.a.reporter self.assertEqual(r.id, self.r.id) self.assertEqual((r.first_name, self.r.last_name), ("John", "Smith")) def test_create(self): # You can also instantiate an Article by passing the Reporter's ID # instead of a Reporter object. a3 = Article( headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id, ) a3.save() self.assertEqual(a3.reporter.id, self.r.id) # Similarly, the reporter ID can be a string. a4 = Article( headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id), ) a4.save() self.assertEqual(repr(a4.reporter), "<Reporter: John Smith>") def test_add(self): # Create an Article via the Reporter object. new_article = self.r.article_set.create( headline="John's second story", pub_date=datetime.date(2005, 7, 29) ) self.assertEqual(repr(new_article), "<Article: John's second story>") self.assertEqual(new_article.reporter.id, self.r.id) # Create a new article, and add it to the article set. new_article2 = Article( headline="Paul's story", pub_date=datetime.date(2006, 1, 17) ) msg = ( "<Article: Paul's story> instance isn't saved. Use bulk=False or save the " "object first." ) with self.assertRaisesMessage(ValueError, msg): self.r.article_set.add(new_article2) self.r.article_set.add(new_article2, bulk=False) self.assertEqual(new_article2.reporter.id, self.r.id) self.assertSequenceEqual( self.r.article_set.all(), [new_article, new_article2, self.a], ) # Add the same article to a different article set - check that it moves. self.r2.article_set.add(new_article2) self.assertEqual(new_article2.reporter.id, self.r2.id) self.assertSequenceEqual(self.r2.article_set.all(), [new_article2]) # Adding an object of the wrong type raises TypeError. with transaction.atomic(): with self.assertRaisesMessage( TypeError, "'Article' instance expected, got <Reporter:" ): self.r.article_set.add(self.r2) self.assertSequenceEqual( self.r.article_set.all(), [new_article, self.a], ) def test_set(self): new_article = self.r.article_set.create( headline="John's second story", pub_date=datetime.date(2005, 7, 29) ) new_article2 = self.r2.article_set.create( headline="Paul's story", pub_date=datetime.date(2006, 1, 17) ) # Assign the article to the reporter. new_article2.reporter = self.r new_article2.save() self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>") self.assertEqual(new_article2.reporter.id, self.r.id) self.assertSequenceEqual( self.r.article_set.all(), [new_article, new_article2, self.a], ) self.assertSequenceEqual(self.r2.article_set.all(), []) # Set the article back again. self.r2.article_set.set([new_article, new_article2]) self.assertSequenceEqual(self.r.article_set.all(), [self.a]) self.assertSequenceEqual( self.r2.article_set.all(), [new_article, new_article2], ) # Funny case - because the ForeignKey cannot be null, # existing members of the set must remain. self.r.article_set.set([new_article]) self.assertSequenceEqual( self.r.article_set.all(), [new_article, self.a], ) self.assertSequenceEqual(self.r2.article_set.all(), [new_article2]) def test_reverse_assignment_deprecation(self): msg = ( "Direct assignment to the reverse side of a related set is " "prohibited. Use article_set.set() instead." ) with self.assertRaisesMessage(TypeError, msg): self.r2.article_set = [] def test_assign(self): new_article = self.r.article_set.create( headline="John's second story", pub_date=datetime.date(2005, 7, 29) ) new_article2 = self.r2.article_set.create( headline="Paul's story", pub_date=datetime.date(2006, 1, 17) ) # Assign the article to the reporter directly using the descriptor. new_article2.reporter = self.r new_article2.save() self.assertEqual(repr(new_article2.reporter), "<Reporter: John Smith>") self.assertEqual(new_article2.reporter.id, self.r.id) self.assertSequenceEqual( self.r.article_set.all(), [new_article, new_article2, self.a], ) self.assertSequenceEqual(self.r2.article_set.all(), []) # Set the article back again using set() method. self.r2.article_set.set([new_article, new_article2]) self.assertSequenceEqual(self.r.article_set.all(), [self.a]) self.assertSequenceEqual( self.r2.article_set.all(), [new_article, new_article2], ) # Because the ForeignKey cannot be null, existing members of the set # must remain. self.r.article_set.set([new_article]) self.assertSequenceEqual( self.r.article_set.all(), [new_article, self.a], ) self.assertSequenceEqual(self.r2.article_set.all(), [new_article2]) # Reporter cannot be null - there should not be a clear or remove method self.assertFalse(hasattr(self.r2.article_set, "remove")) self.assertFalse(hasattr(self.r2.article_set, "clear")) def test_assign_fk_id_value(self): parent = Parent.objects.create(name="jeff") child1 = Child.objects.create(name="frank", parent=parent) child2 = Child.objects.create(name="randy", parent=parent) parent.bestchild = child1 parent.save() parent.bestchild_id = child2.pk parent.save() self.assertEqual(parent.bestchild_id, child2.pk) self.assertFalse(Parent.bestchild.is_cached(parent)) self.assertEqual(parent.bestchild, child2) self.assertTrue(Parent.bestchild.is_cached(parent)) # Reassigning the same value doesn't clear cached instance. parent.bestchild_id = child2.pk self.assertTrue(Parent.bestchild.is_cached(parent)) def test_assign_fk_id_none(self): parent = Parent.objects.create(name="jeff") child = Child.objects.create(name="frank", parent=parent) parent.bestchild = child parent.save() parent.bestchild_id = None parent.save() self.assertIsNone(parent.bestchild_id) self.assertFalse(Parent.bestchild.is_cached(parent)) self.assertIsNone(parent.bestchild) self.assertTrue(Parent.bestchild.is_cached(parent)) def test_selects(self): new_article1 = self.r.article_set.create( headline="John's second story", pub_date=datetime.date(2005, 7, 29), ) new_article2 = self.r2.article_set.create( headline="Paul's story", pub_date=datetime.date(2006, 1, 17), ) # Reporter objects have access to their related Article objects. self.assertSequenceEqual( self.r.article_set.all(), [new_article1, self.a], ) self.assertSequenceEqual( self.r.article_set.filter(headline__startswith="This"), [self.a] ) self.assertEqual(self.r.article_set.count(), 2) self.assertEqual(self.r2.article_set.count(), 1) # Get articles by id self.assertSequenceEqual(Article.objects.filter(id__exact=self.a.id), [self.a]) self.assertSequenceEqual(Article.objects.filter(pk=self.a.id), [self.a]) # Query on an article property self.assertSequenceEqual( Article.objects.filter(headline__startswith="This"), [self.a] ) # The API automatically follows relationships as far as you need. # Use double underscores to separate relationships. # This works as many levels deep as you want. There's no limit. # Find all Articles for any Reporter whose first name is "John". self.assertSequenceEqual( Article.objects.filter(reporter__first_name__exact="John"), [new_article1, self.a], ) # Implied __exact also works self.assertSequenceEqual( Article.objects.filter(reporter__first_name="John"), [new_article1, self.a], ) # Query twice over the related field. self.assertSequenceEqual( Article.objects.filter( reporter__first_name__exact="John", reporter__last_name__exact="Smith" ), [new_article1, self.a], ) # The underlying query only makes one join when a related table is # referenced twice. queryset = Article.objects.filter( reporter__first_name__exact="John", reporter__last_name__exact="Smith" ) self.assertNumQueries(1, list, queryset) self.assertEqual( queryset.query.get_compiler(queryset.db).as_sql()[0].count("INNER JOIN"), 1 ) # The automatically joined table has a predictable name. self.assertSequenceEqual( Article.objects.filter(reporter__first_name__exact="John").extra( where=["many_to_one_reporter.last_name='Smith'"] ), [new_article1, self.a], ) # ... and should work fine with the string that comes out of # forms.Form.cleaned_data. self.assertQuerysetEqual( ( Article.objects.filter(reporter__first_name__exact="John").extra( where=["many_to_one_reporter.last_name='%s'" % "Smith"] ) ), [new_article1, self.a], ) # Find all Articles for a Reporter. # Use direct ID check, pk check, and object comparison self.assertSequenceEqual( Article.objects.filter(reporter__id__exact=self.r.id), [new_article1, self.a], ) self.assertSequenceEqual( Article.objects.filter(reporter__pk=self.r.id), [new_article1, self.a], ) self.assertSequenceEqual( Article.objects.filter(reporter=self.r.id), [new_article1, self.a], ) self.assertSequenceEqual( Article.objects.filter(reporter=self.r), [new_article1, self.a], ) self.assertSequenceEqual( Article.objects.filter(reporter__in=[self.r.id, self.r2.id]).distinct(), [new_article1, new_article2, self.a], ) self.assertSequenceEqual( Article.objects.filter(reporter__in=[self.r, self.r2]).distinct(), [new_article1, new_article2, self.a], ) # You can also use a queryset instead of a literal list of instances. # The queryset must be reduced to a list of values using values(), # then converted into a query self.assertSequenceEqual( Article.objects.filter( reporter__in=Reporter.objects.filter(first_name="John") .values("pk") .query ).distinct(), [new_article1, self.a], ) def test_reverse_selects(self): a3 = Article.objects.create( headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id, ) Article.objects.create( headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id, ) john_smith = [self.r] # Reporters can be queried self.assertSequenceEqual( Reporter.objects.filter(id__exact=self.r.id), john_smith ) self.assertSequenceEqual(Reporter.objects.filter(pk=self.r.id), john_smith) self.assertSequenceEqual( Reporter.objects.filter(first_name__startswith="John"), john_smith ) # Reporters can query in opposite direction of ForeignKey definition self.assertSequenceEqual( Reporter.objects.filter(article__id__exact=self.a.id), john_smith ) self.assertSequenceEqual( Reporter.objects.filter(article__pk=self.a.id), john_smith ) self.assertSequenceEqual(Reporter.objects.filter(article=self.a.id), john_smith) self.assertSequenceEqual(Reporter.objects.filter(article=self.a), john_smith) self.assertSequenceEqual( Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(), john_smith, ) self.assertSequenceEqual( Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith ) self.assertSequenceEqual( Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith ) self.assertCountEqual( Reporter.objects.filter(article__headline__startswith="T"), [self.r, self.r], ) self.assertSequenceEqual( Reporter.objects.filter(article__headline__startswith="T").distinct(), john_smith, ) # Counting in the opposite direction works in conjunction with distinct() self.assertEqual( Reporter.objects.filter(article__headline__startswith="T").count(), 2 ) self.assertEqual( Reporter.objects.filter(article__headline__startswith="T") .distinct() .count(), 1, ) # Queries can go round in circles. self.assertCountEqual( Reporter.objects.filter(article__reporter__first_name__startswith="John"), [self.r, self.r, self.r], ) self.assertSequenceEqual( Reporter.objects.filter( article__reporter__first_name__startswith="John" ).distinct(), john_smith, ) self.assertSequenceEqual( Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith, ) # Implied __exact also works. self.assertSequenceEqual( Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith ) # It's possible to use values() calls across many-to-one relations. # (Note, too, that we clear the ordering here so as not to drag the # 'headline' field into the columns being used to determine uniqueness) d = {"reporter__first_name": "John", "reporter__last_name": "Smith"} qs = ( Article.objects.filter( reporter=self.r, ) .distinct() .order_by() .values("reporter__first_name", "reporter__last_name") ) self.assertEqual([d], list(qs)) def test_select_related(self): # Article.objects.select_related().dates() works properly when there # are multiple Articles with the same date but different foreign-key # objects (Reporters). r1 = Reporter.objects.create( first_name="Mike", last_name="Royko", email="[email protected]" ) r2 = Reporter.objects.create( first_name="John", last_name="Kass", email="[email protected]" ) Article.objects.create( headline="First", pub_date=datetime.date(1980, 4, 23), reporter=r1 ) Article.objects.create( headline="Second", pub_date=datetime.date(1980, 4, 23), reporter=r2 ) self.assertEqual( list(Article.objects.select_related().dates("pub_date", "day")), [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)], ) self.assertEqual( list(Article.objects.select_related().dates("pub_date", "month")), [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)], ) self.assertEqual( list(Article.objects.select_related().dates("pub_date", "year")), [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)], ) def test_delete(self): new_article1 = self.r.article_set.create( headline="John's second story", pub_date=datetime.date(2005, 7, 29), ) new_article2 = self.r2.article_set.create( headline="Paul's story", pub_date=datetime.date(2006, 1, 17), ) new_article3 = Article.objects.create( headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id, ) new_article4 = Article.objects.create( headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id), ) # If you delete a reporter, their articles will be deleted. self.assertSequenceEqual( Article.objects.all(), [new_article4, new_article1, new_article2, new_article3, self.a], ) self.assertSequenceEqual( Reporter.objects.order_by("first_name"), [self.r, self.r2], ) self.r2.delete() self.assertSequenceEqual( Article.objects.all(), [new_article4, new_article1, new_article3, self.a], ) self.assertSequenceEqual(Reporter.objects.order_by("first_name"), [self.r]) # You can delete using a JOIN in the query. Reporter.objects.filter(article__headline__startswith="This").delete() self.assertSequenceEqual(Reporter.objects.all(), []) self.assertSequenceEqual(Article.objects.all(), []) def test_explicit_fk(self): # Create a new Article with get_or_create using an explicit value # for a ForeignKey. a2, created = Article.objects.get_or_create( headline="John's second test", pub_date=datetime.date(2011, 5, 7), reporter_id=self.r.id, ) self.assertTrue(created) self.assertEqual(a2.reporter.id, self.r.id) # You can specify filters containing the explicit FK value. self.assertSequenceEqual( Article.objects.filter(reporter_id__exact=self.r.id), [a2, self.a], ) # Create an Article by Paul for the same date. a3 = Article.objects.create( headline="Paul's commentary", pub_date=datetime.date(2011, 5, 7), reporter_id=self.r2.id, ) self.assertEqual(a3.reporter.id, self.r2.id) # Get should respect explicit foreign keys as well. msg = "get() returned more than one Article -- it returned 2!" with self.assertRaisesMessage(MultipleObjectsReturned, msg): Article.objects.get(reporter_id=self.r.id) self.assertEqual( repr(a3), repr( Article.objects.get( reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7) ) ), ) def test_deepcopy_and_circular_references(self): # Regression for #12876 -- Model methods that include queries that # recursive don't cause recursion depth problems under deepcopy. self.r.cached_query = Article.objects.filter(reporter=self.r) self.assertEqual(repr(deepcopy(self.r)), "<Reporter: John Smith>") def test_manager_class_caching(self): r1 = Reporter.objects.create(first_name="Mike") r2 = Reporter.objects.create(first_name="John") # Same twice self.assertIs(r1.article_set.__class__, r1.article_set.__class__) # Same as each other self.assertIs(r1.article_set.__class__, r2.article_set.__class__) def test_create_relation_with_gettext_lazy(self): reporter = Reporter.objects.create( first_name="John", last_name="Smith", email="[email protected]" ) lazy = gettext_lazy("test") reporter.article_set.create(headline=lazy, pub_date=datetime.date(2011, 6, 10)) notlazy = str(lazy) article = reporter.article_set.get() self.assertEqual(article.headline, notlazy) def test_values_list_exception(self): expected_message = ( "Cannot resolve keyword 'notafield' into field. Choices are: %s" ) reporter_fields = ", ".join(sorted(f.name for f in Reporter._meta.get_fields())) with self.assertRaisesMessage(FieldError, expected_message % reporter_fields): Article.objects.values_list("reporter__notafield") article_fields = ", ".join( ["EXTRA"] + sorted(f.name for f in Article._meta.get_fields()) ) with self.assertRaisesMessage(FieldError, expected_message % article_fields): Article.objects.extra(select={"EXTRA": "EXTRA_SELECT"}).values_list( "notafield" ) def test_fk_assignment_and_related_object_cache(self): # Tests of ForeignKey assignment and the related-object cache (see #6886). p = Parent.objects.create(name="Parent") c = Child.objects.create(name="Child", parent=p) # Look up the object again so that we get a "fresh" object. c = Child.objects.get(name="Child") p = c.parent # Accessing the related object again returns the exactly same object. self.assertIs(c.parent, p) # But if we kill the cache, we get a new object. del c._state.fields_cache["parent"] self.assertIsNot(c.parent, p) # Assigning a new object results in that object getting cached immediately. p2 = Parent.objects.create(name="Parent 2") c.parent = p2 self.assertIs(c.parent, p2) # Assigning None succeeds if field is null=True. p.bestchild = None self.assertIsNone(p.bestchild) # bestchild should still be None after saving. p.save() self.assertIsNone(p.bestchild) # bestchild should still be None after fetching the object again. p = Parent.objects.get(name="Parent") self.assertIsNone(p.bestchild) # Assigning None will not fail: Child.parent is null=False. setattr(c, "parent", None) # You also can't assign an object of the wrong type here msg = ( 'Cannot assign "<First: First object (1)>": "Child.parent" must ' 'be a "Parent" instance.' ) with self.assertRaisesMessage(ValueError, msg): setattr(c, "parent", First(id=1, second=1)) # You can assign None to Child.parent during object creation. Child(name="xyzzy", parent=None) # But when trying to save a Child with parent=None, the database will # raise IntegrityError. with self.assertRaises(IntegrityError), transaction.atomic(): Child.objects.create(name="xyzzy", parent=None) # Creation using keyword argument should cache the related object. p = Parent.objects.get(name="Parent") c = Child(parent=p) self.assertIs(c.parent, p) # Creation using keyword argument and unsaved related instance (#8070). p = Parent() msg = ( "save() prohibited to prevent data loss due to unsaved related object " "'parent'." ) with self.assertRaisesMessage(ValueError, msg): Child.objects.create(parent=p) with self.assertRaisesMessage(ValueError, msg): ToFieldChild.objects.create(parent=p) # Creation using attname keyword argument and an id will cause the # related object to be fetched. p = Parent.objects.get(name="Parent") c = Child(parent_id=p.id) self.assertIsNot(c.parent, p) self.assertEqual(c.parent, p) def test_save_nullable_fk_after_parent(self): parent = Parent() child = ChildNullableParent(parent=parent) parent.save() child.save() child.refresh_from_db() self.assertEqual(child.parent, parent) def test_save_nullable_fk_after_parent_with_to_field(self): parent = Parent(name="jeff") child = ToFieldChild(parent=parent) parent.save() child.save() child.refresh_from_db() self.assertEqual(child.parent, parent) self.assertEqual(child.parent_id, parent.name) def test_save_fk_after_parent_with_non_numeric_pk_set_on_child(self): parent = ParentStringPrimaryKey() child = ChildStringPrimaryKeyParent(parent=parent) child.parent.name = "jeff" parent.save() child.save() child.refresh_from_db() self.assertEqual(child.parent, parent) self.assertEqual(child.parent_id, parent.name) def test_fk_to_bigautofield(self): ch = City.objects.create(name="Chicago") District.objects.create(city=ch, name="Far South") District.objects.create(city=ch, name="North") ny = City.objects.create(name="New York", id=2**33) District.objects.create(city=ny, name="Brooklyn") District.objects.create(city=ny, name="Manhattan") def test_fk_to_smallautofield(self): us = Country.objects.create(name="United States") City.objects.create(country=us, name="Chicago") City.objects.create(country=us, name="New York") uk = Country.objects.create(name="United Kingdom", id=2**11) City.objects.create(country=uk, name="London") City.objects.create(country=uk, name="Edinburgh") def test_multiple_foreignkeys(self): # Test of multiple ForeignKeys to the same model (bug #7125). c1 = Category.objects.create(name="First") c2 = Category.objects.create(name="Second") c3 = Category.objects.create(name="Third") r1 = Record.objects.create(category=c1) r2 = Record.objects.create(category=c1) r3 = Record.objects.create(category=c2) r4 = Record.objects.create(category=c2) r5 = Record.objects.create(category=c3) Relation.objects.create(left=r1, right=r2) Relation.objects.create(left=r3, right=r4) rel = Relation.objects.create(left=r1, right=r3) Relation.objects.create(left=r5, right=r2) Relation.objects.create(left=r3, right=r2) q1 = Relation.objects.filter( left__category__name__in=["First"], right__category__name__in=["Second"] ) self.assertSequenceEqual(q1, [rel]) q2 = Category.objects.filter( record__left_set__right__category__name="Second" ).order_by("name") self.assertSequenceEqual(q2, [c1, c2]) p = Parent.objects.create(name="Parent") c = Child.objects.create(name="Child", parent=p) msg = 'Cannot assign "%r": "Child.parent" must be a "Parent" instance.' % c with self.assertRaisesMessage(ValueError, msg): Child.objects.create(name="Grandchild", parent=c) def test_fk_instantiation_outside_model(self): # Regression for #12190 -- Should be able to instantiate a FK outside # of a model, and interrogate its related field. cat = models.ForeignKey(Category, models.CASCADE) self.assertEqual("id", cat.remote_field.get_related_field().name) def test_relation_unsaved(self): Third.objects.create(name="Third 1") Third.objects.create(name="Third 2") th = Third(name="testing") # The object isn't saved and the relation cannot be used. msg = ( "'Third' instance needs to have a primary key value before this " "relationship can be used." ) with self.assertRaisesMessage(ValueError, msg): th.child_set.count() th.save() # Now the model is saved, so we will need to execute a query. with self.assertNumQueries(1): self.assertEqual(th.child_set.count(), 0) def test_related_object(self): public_school = School.objects.create(is_public=True) public_student = Student.objects.create(school=public_school) private_school = School.objects.create(is_public=False) private_student = Student.objects.create(school=private_school) # Only one school is available via all() due to the custom default manager. self.assertSequenceEqual(School.objects.all(), [public_school]) self.assertEqual(public_student.school, public_school) # Make sure the base manager is used so that a student can still access # its related school even if the default manager doesn't normally # allow it. self.assertEqual(private_student.school, private_school) School._meta.base_manager_name = "objects" School._meta._expire_cache() try: private_student = Student.objects.get(pk=private_student.pk) with self.assertRaises(School.DoesNotExist): private_student.school finally: School._meta.base_manager_name = None School._meta._expire_cache() def test_hasattr_related_object(self): # The exception raised on attribute access when a related object # doesn't exist should be an instance of a subclass of `AttributeError` # refs #21563 self.assertFalse(hasattr(Article(), "reporter")) def test_clear_after_prefetch(self): c = City.objects.create(name="Musical City") d = District.objects.create(name="Ladida", city=c) city = City.objects.prefetch_related("districts").get(id=c.id) self.assertSequenceEqual(city.districts.all(), [d]) city.districts.clear() self.assertSequenceEqual(city.districts.all(), []) def test_remove_after_prefetch(self): c = City.objects.create(name="Musical City") d = District.objects.create(name="Ladida", city=c) city = City.objects.prefetch_related("districts").get(id=c.id) self.assertSequenceEqual(city.districts.all(), [d]) city.districts.remove(d) self.assertSequenceEqual(city.districts.all(), []) def test_add_after_prefetch(self): c = City.objects.create(name="Musical City") District.objects.create(name="Ladida", city=c) d2 = District.objects.create(name="Ladidu") city = City.objects.prefetch_related("districts").get(id=c.id) self.assertEqual(city.districts.count(), 1) city.districts.add(d2) self.assertEqual(city.districts.count(), 2) def test_set_after_prefetch(self): c = City.objects.create(name="Musical City") District.objects.create(name="Ladida", city=c) d2 = District.objects.create(name="Ladidu") city = City.objects.prefetch_related("districts").get(id=c.id) self.assertEqual(city.districts.count(), 1) city.districts.set([d2]) self.assertSequenceEqual(city.districts.all(), [d2]) def test_add_then_remove_after_prefetch(self): c = City.objects.create(name="Musical City") District.objects.create(name="Ladida", city=c) d2 = District.objects.create(name="Ladidu") city = City.objects.prefetch_related("districts").get(id=c.id) self.assertEqual(city.districts.count(), 1) city.districts.add(d2) self.assertEqual(city.districts.count(), 2) city.districts.remove(d2) self.assertEqual(city.districts.count(), 1) def test_cached_relation_invalidated_on_save(self): """ Model.save() invalidates stale ForeignKey relations after a primary key assignment. """ self.assertEqual(self.a.reporter, self.r) # caches a.reporter self.a.reporter_id = self.r2.pk self.a.save() self.assertEqual(self.a.reporter, self.r2) def test_cached_foreign_key_with_to_field_not_cleared_by_save(self): parent = Parent.objects.create(name="a") child = ToFieldChild.objects.create(parent=parent) with self.assertNumQueries(0): self.assertIs(child.parent, parent) def test_reverse_foreign_key_instance_to_field_caching(self): parent = Parent.objects.create(name="a") ToFieldChild.objects.create(parent=parent) child = parent.to_field_children.get() with self.assertNumQueries(0): self.assertIs(child.parent, parent) def test_add_remove_set_by_pk_raises(self): usa = Country.objects.create(name="United States") chicago = City.objects.create(name="Chicago") msg = "'City' instance expected, got %s" % chicago.pk with self.assertRaisesMessage(TypeError, msg): usa.cities.add(chicago.pk) with self.assertRaisesMessage(TypeError, msg): usa.cities.remove(chicago.pk) with self.assertRaisesMessage(TypeError, msg): usa.cities.set([chicago.pk])
694ba71fa81cc37701c02cda74200f8af18de0907096227c3e6783e84c5aa0be
""" Many-to-one relationships To define a many-to-one relationship, use ``ForeignKey()``. """ from django.db import models class Reporter(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) email = models.EmailField() def __str__(self): return "%s %s" % (self.first_name, self.last_name) class Article(models.Model): headline = models.CharField(max_length=100) pub_date = models.DateField() reporter = models.ForeignKey(Reporter, models.CASCADE) class Meta: ordering = ("headline",) def __str__(self): return self.headline class Country(models.Model): id = models.SmallAutoField(primary_key=True) name = models.CharField(max_length=50) class City(models.Model): id = models.BigAutoField(primary_key=True) country = models.ForeignKey( Country, models.CASCADE, related_name="cities", null=True ) name = models.CharField(max_length=50) class District(models.Model): city = models.ForeignKey(City, models.CASCADE, related_name="districts", null=True) name = models.CharField(max_length=50) def __str__(self): return self.name # If ticket #1578 ever slips back in, these models will not be able to be # created (the field names being lowercased versions of their opposite classes # is important here). class First(models.Model): second = models.IntegerField() class Second(models.Model): first = models.ForeignKey(First, models.CASCADE, related_name="the_first") # Protect against repetition of #1839, #2415 and #2536. class Third(models.Model): name = models.CharField(max_length=20) third = models.ForeignKey( "self", models.SET_NULL, null=True, related_name="child_set" ) class Parent(models.Model): name = models.CharField(max_length=20, unique=True) bestchild = models.ForeignKey( "Child", models.SET_NULL, null=True, related_name="favored_by" ) class ParentStringPrimaryKey(models.Model): name = models.CharField(primary_key=True, max_length=15) class Child(models.Model): name = models.CharField(max_length=20) parent = models.ForeignKey(Parent, models.CASCADE) class ChildNullableParent(models.Model): parent = models.ForeignKey(Parent, models.CASCADE, null=True) class ChildStringPrimaryKeyParent(models.Model): parent = models.ForeignKey(ParentStringPrimaryKey, on_delete=models.CASCADE) class ToFieldChild(models.Model): parent = models.ForeignKey( Parent, models.CASCADE, to_field="name", related_name="to_field_children" ) # Multiple paths to the same model (#7110, #7125) class Category(models.Model): name = models.CharField(max_length=20) def __str__(self): return self.name class Record(models.Model): category = models.ForeignKey(Category, models.CASCADE) class Relation(models.Model): left = models.ForeignKey(Record, models.CASCADE, related_name="left_set") right = models.ForeignKey(Record, models.CASCADE, related_name="right_set") def __str__(self): return "%s - %s" % (self.left.category.name, self.right.category.name) # Test related objects visibility. class SchoolManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(is_public=True) class School(models.Model): is_public = models.BooleanField(default=False) objects = SchoolManager() class Student(models.Model): school = models.ForeignKey(School, models.CASCADE)
50c6a697ea23e96488c2f61e9d86d55fcd2056325f5b9c830a3fd74fc503eb89
from django.db.models.utils import create_namedtuple_class from django.test import SimpleTestCase class NamedTupleClassTests(SimpleTestCase): def test_immutability(self): row_class = create_namedtuple_class("field1", "field2") row = row_class("value1", "value2") with self.assertRaises(AttributeError): row.field3 = "value3"
db89702e1fd39cb64473385ddad613232dfbbd90b40813aff909d008089d95cb
from django.contrib.sessions.backends.base import SessionBase class SessionStore(SessionBase): """Session store without support for clearing expired sessions.""" pass
7b9dfe8f158c8087ca1cfd535bd4a6210e37ee10a0302d67e821305e081605fe
import base64 import os import shutil import string import tempfile import unittest from datetime import timedelta from http import cookies from pathlib import Path from unittest import mock from django.conf import settings from django.contrib.sessions.backends.base import UpdateError from django.contrib.sessions.backends.cache import SessionStore as CacheSession from django.contrib.sessions.backends.cached_db import SessionStore as CacheDBSession from django.contrib.sessions.backends.db import SessionStore as DatabaseSession from django.contrib.sessions.backends.file import SessionStore as FileSession from django.contrib.sessions.backends.signed_cookies import ( SessionStore as CookieSession, ) from django.contrib.sessions.exceptions import InvalidSessionKey, SessionInterrupted from django.contrib.sessions.middleware import SessionMiddleware from django.contrib.sessions.models import Session from django.contrib.sessions.serializers import JSONSerializer from django.core import management from django.core.cache import caches from django.core.cache.backends.base import InvalidCacheBackendError from django.core.exceptions import ImproperlyConfigured from django.core.signing import TimestampSigner from django.http import HttpResponse from django.test import ( RequestFactory, SimpleTestCase, TestCase, ignore_warnings, override_settings, ) from django.utils import timezone from .models import SessionStore as CustomDatabaseSession class SessionTestsMixin: # This does not inherit from TestCase to avoid any tests being run with this # class, which wouldn't work, and to allow different TestCase subclasses to # be used. backend = None # subclasses must specify def setUp(self): self.session = self.backend() def tearDown(self): # NB: be careful to delete any sessions created; stale sessions fill up # the /tmp (with some backends) and eventually overwhelm it after lots # of runs (think buildbots) self.session.delete() def test_new_session(self): self.assertIs(self.session.modified, False) self.assertIs(self.session.accessed, False) def test_get_empty(self): self.assertIsNone(self.session.get("cat")) def test_store(self): self.session["cat"] = "dog" self.assertIs(self.session.modified, True) self.assertEqual(self.session.pop("cat"), "dog") def test_pop(self): self.session["some key"] = "exists" # Need to reset these to pretend we haven't accessed it: self.accessed = False self.modified = False self.assertEqual(self.session.pop("some key"), "exists") self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, True) self.assertIsNone(self.session.get("some key")) def test_pop_default(self): self.assertEqual( self.session.pop("some key", "does not exist"), "does not exist" ) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_pop_default_named_argument(self): self.assertEqual( self.session.pop("some key", default="does not exist"), "does not exist" ) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_pop_no_default_keyerror_raised(self): with self.assertRaises(KeyError): self.session.pop("some key") def test_setdefault(self): self.assertEqual(self.session.setdefault("foo", "bar"), "bar") self.assertEqual(self.session.setdefault("foo", "baz"), "bar") self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, True) def test_update(self): self.session.update({"update key": 1}) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, True) self.assertEqual(self.session.get("update key", None), 1) def test_has_key(self): self.session["some key"] = 1 self.session.modified = False self.session.accessed = False self.assertIn("some key", self.session) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_values(self): self.assertEqual(list(self.session.values()), []) self.assertIs(self.session.accessed, True) self.session["some key"] = 1 self.session.modified = False self.session.accessed = False self.assertEqual(list(self.session.values()), [1]) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_keys(self): self.session["x"] = 1 self.session.modified = False self.session.accessed = False self.assertEqual(list(self.session.keys()), ["x"]) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_items(self): self.session["x"] = 1 self.session.modified = False self.session.accessed = False self.assertEqual(list(self.session.items()), [("x", 1)]) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, False) def test_clear(self): self.session["x"] = 1 self.session.modified = False self.session.accessed = False self.assertEqual(list(self.session.items()), [("x", 1)]) self.session.clear() self.assertEqual(list(self.session.items()), []) self.assertIs(self.session.accessed, True) self.assertIs(self.session.modified, True) def test_save(self): self.session.save() self.assertIs(self.session.exists(self.session.session_key), True) def test_delete(self): self.session.save() self.session.delete(self.session.session_key) self.assertIs(self.session.exists(self.session.session_key), False) def test_flush(self): self.session["foo"] = "bar" self.session.save() prev_key = self.session.session_key self.session.flush() self.assertIs(self.session.exists(prev_key), False) self.assertNotEqual(self.session.session_key, prev_key) self.assertIsNone(self.session.session_key) self.assertIs(self.session.modified, True) self.assertIs(self.session.accessed, True) def test_cycle(self): self.session["a"], self.session["b"] = "c", "d" self.session.save() prev_key = self.session.session_key prev_data = list(self.session.items()) self.session.cycle_key() self.assertIs(self.session.exists(prev_key), False) self.assertNotEqual(self.session.session_key, prev_key) self.assertEqual(list(self.session.items()), prev_data) def test_cycle_with_no_session_cache(self): self.session["a"], self.session["b"] = "c", "d" self.session.save() prev_data = self.session.items() self.session = self.backend(self.session.session_key) self.assertIs(hasattr(self.session, "_session_cache"), False) self.session.cycle_key() self.assertCountEqual(self.session.items(), prev_data) def test_save_doesnt_clear_data(self): self.session["a"] = "b" self.session.save() self.assertEqual(self.session["a"], "b") def test_invalid_key(self): # Submitting an invalid session key (either by guessing, or if the db has # removed the key) results in a new key being generated. try: session = self.backend("1") session.save() self.assertNotEqual(session.session_key, "1") self.assertIsNone(session.get("cat")) session.delete() finally: # Some backends leave a stale cache entry for the invalid # session key; make sure that entry is manually deleted session.delete("1") def test_session_key_empty_string_invalid(self): """Falsey values (Such as an empty string) are rejected.""" self.session._session_key = "" self.assertIsNone(self.session.session_key) def test_session_key_too_short_invalid(self): """Strings shorter than 8 characters are rejected.""" self.session._session_key = "1234567" self.assertIsNone(self.session.session_key) def test_session_key_valid_string_saved(self): """Strings of length 8 and up are accepted and stored.""" self.session._session_key = "12345678" self.assertEqual(self.session.session_key, "12345678") def test_session_key_is_read_only(self): def set_session_key(session): session.session_key = session._get_new_session_key() with self.assertRaises(AttributeError): set_session_key(self.session) # Custom session expiry def test_default_expiry(self): # A normal session has a max age equal to settings self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE) # So does a custom session with an idle expiration time of 0 (but it'll # expire at browser close) self.session.set_expiry(0) self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE) def test_custom_expiry_seconds(self): modification = timezone.now() self.session.set_expiry(10) date = self.session.get_expiry_date(modification=modification) self.assertEqual(date, modification + timedelta(seconds=10)) age = self.session.get_expiry_age(modification=modification) self.assertEqual(age, 10) def test_custom_expiry_timedelta(self): modification = timezone.now() # Mock timezone.now, because set_expiry calls it on this code path. original_now = timezone.now try: timezone.now = lambda: modification self.session.set_expiry(timedelta(seconds=10)) finally: timezone.now = original_now date = self.session.get_expiry_date(modification=modification) self.assertEqual(date, modification + timedelta(seconds=10)) age = self.session.get_expiry_age(modification=modification) self.assertEqual(age, 10) def test_custom_expiry_datetime(self): modification = timezone.now() self.session.set_expiry(modification + timedelta(seconds=10)) date = self.session.get_expiry_date(modification=modification) self.assertEqual(date, modification + timedelta(seconds=10)) age = self.session.get_expiry_age(modification=modification) self.assertEqual(age, 10) def test_custom_expiry_reset(self): self.session.set_expiry(None) self.session.set_expiry(10) self.session.set_expiry(None) self.assertEqual(self.session.get_expiry_age(), settings.SESSION_COOKIE_AGE) def test_get_expire_at_browser_close(self): # Tests get_expire_at_browser_close with different settings and different # set_expiry calls with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=False): self.session.set_expiry(10) self.assertIs(self.session.get_expire_at_browser_close(), False) self.session.set_expiry(0) self.assertIs(self.session.get_expire_at_browser_close(), True) self.session.set_expiry(None) self.assertIs(self.session.get_expire_at_browser_close(), False) with override_settings(SESSION_EXPIRE_AT_BROWSER_CLOSE=True): self.session.set_expiry(10) self.assertIs(self.session.get_expire_at_browser_close(), False) self.session.set_expiry(0) self.assertIs(self.session.get_expire_at_browser_close(), True) self.session.set_expiry(None) self.assertIs(self.session.get_expire_at_browser_close(), True) def test_decode(self): # Ensure we can decode what we encode data = {"a test key": "a test value"} encoded = self.session.encode(data) self.assertEqual(self.session.decode(encoded), data) def test_decode_failure_logged_to_security(self): tests = [ base64.b64encode(b"flaskdj:alkdjf").decode("ascii"), "bad:encoded:value", ] for encoded in tests: with self.subTest(encoded=encoded): with self.assertLogs( "django.security.SuspiciousSession", "WARNING" ) as cm: self.assertEqual(self.session.decode(encoded), {}) # The failed decode is logged. self.assertIn("Session data corrupted", cm.output[0]) def test_decode_serializer_exception(self): signer = TimestampSigner(salt=self.session.key_salt) encoded = signer.sign(b"invalid data") self.assertEqual(self.session.decode(encoded), {}) def test_actual_expiry(self): old_session_key = None new_session_key = None try: self.session["foo"] = "bar" self.session.set_expiry(-timedelta(seconds=10)) self.session.save() old_session_key = self.session.session_key # With an expiry date in the past, the session expires instantly. new_session = self.backend(self.session.session_key) new_session_key = new_session.session_key self.assertNotIn("foo", new_session) finally: self.session.delete(old_session_key) self.session.delete(new_session_key) def test_session_load_does_not_create_record(self): """ Loading an unknown session key does not create a session record. Creating session records on load is a DOS vulnerability. """ session = self.backend("someunknownkey") session.load() self.assertIsNone(session.session_key) self.assertIs(session.exists(session.session_key), False) # provided unknown key was cycled, not reused self.assertNotEqual(session.session_key, "someunknownkey") def test_session_save_does_not_resurrect_session_logged_out_in_other_context(self): """ Sessions shouldn't be resurrected by a concurrent request. """ # Create new session. s1 = self.backend() s1["test_data"] = "value1" s1.save(must_create=True) # Logout in another context. s2 = self.backend(s1.session_key) s2.delete() # Modify session in first context. s1["test_data"] = "value2" with self.assertRaises(UpdateError): # This should throw an exception as the session is deleted, not # resurrect the session. s1.save() self.assertEqual(s1.load(), {}) class DatabaseSessionTests(SessionTestsMixin, TestCase): backend = DatabaseSession session_engine = "django.contrib.sessions.backends.db" @property def model(self): return self.backend.get_model_class() def test_session_str(self): "Session repr should be the session key." self.session["x"] = 1 self.session.save() session_key = self.session.session_key s = self.model.objects.get(session_key=session_key) self.assertEqual(str(s), session_key) def test_session_get_decoded(self): """ Test we can use Session.get_decoded to retrieve data stored in normal way """ self.session["x"] = 1 self.session.save() s = self.model.objects.get(session_key=self.session.session_key) self.assertEqual(s.get_decoded(), {"x": 1}) def test_sessionmanager_save(self): """ Test SessionManager.save method """ # Create a session self.session["y"] = 1 self.session.save() s = self.model.objects.get(session_key=self.session.session_key) # Change it self.model.objects.save(s.session_key, {"y": 2}, s.expire_date) # Clear cache, so that it will be retrieved from DB del self.session._session_cache self.assertEqual(self.session["y"], 2) def test_clearsessions_command(self): """ Test clearsessions command for clearing expired sessions. """ self.assertEqual(0, self.model.objects.count()) # One object in the future self.session["foo"] = "bar" self.session.set_expiry(3600) self.session.save() # One object in the past other_session = self.backend() other_session["foo"] = "bar" other_session.set_expiry(-3600) other_session.save() # Two sessions are in the database before clearsessions... self.assertEqual(2, self.model.objects.count()) with override_settings(SESSION_ENGINE=self.session_engine): management.call_command("clearsessions") # ... and one is deleted. self.assertEqual(1, self.model.objects.count()) @override_settings(USE_TZ=True) class DatabaseSessionWithTimeZoneTests(DatabaseSessionTests): pass class CustomDatabaseSessionTests(DatabaseSessionTests): backend = CustomDatabaseSession session_engine = "sessions_tests.models" custom_session_cookie_age = 60 * 60 * 24 # One day. def test_extra_session_field(self): # Set the account ID to be picked up by a custom session storage # and saved to a custom session model database column. self.session["_auth_user_id"] = 42 self.session.save() # Make sure that the customized create_model_instance() was called. s = self.model.objects.get(session_key=self.session.session_key) self.assertEqual(s.account_id, 42) # Make the session "anonymous". self.session.pop("_auth_user_id") self.session.save() # Make sure that save() on an existing session did the right job. s = self.model.objects.get(session_key=self.session.session_key) self.assertIsNone(s.account_id) def test_custom_expiry_reset(self): self.session.set_expiry(None) self.session.set_expiry(10) self.session.set_expiry(None) self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age) def test_default_expiry(self): self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age) self.session.set_expiry(0) self.assertEqual(self.session.get_expiry_age(), self.custom_session_cookie_age) class CacheDBSessionTests(SessionTestsMixin, TestCase): backend = CacheDBSession def test_exists_searches_cache_first(self): self.session.save() with self.assertNumQueries(0): self.assertIs(self.session.exists(self.session.session_key), True) # Some backends might issue a warning @ignore_warnings(module="django.core.cache.backends.base") def test_load_overlong_key(self): self.session._session_key = (string.ascii_letters + string.digits) * 20 self.assertEqual(self.session.load(), {}) @override_settings(SESSION_CACHE_ALIAS="sessions") def test_non_default_cache(self): # 21000 - CacheDB backend should respect SESSION_CACHE_ALIAS. with self.assertRaises(InvalidCacheBackendError): self.backend() @override_settings(USE_TZ=True) class CacheDBSessionWithTimeZoneTests(CacheDBSessionTests): pass class FileSessionTests(SessionTestsMixin, SimpleTestCase): backend = FileSession def setUp(self): # Do file session tests in an isolated directory, and kill it after we're done. self.original_session_file_path = settings.SESSION_FILE_PATH self.temp_session_store = settings.SESSION_FILE_PATH = self.mkdtemp() # Reset the file session backend's internal caches if hasattr(self.backend, "_storage_path"): del self.backend._storage_path super().setUp() def tearDown(self): super().tearDown() settings.SESSION_FILE_PATH = self.original_session_file_path shutil.rmtree(self.temp_session_store) def mkdtemp(self): return tempfile.mkdtemp() @override_settings( SESSION_FILE_PATH="/if/this/directory/exists/you/have/a/weird/computer", ) def test_configuration_check(self): del self.backend._storage_path # Make sure the file backend checks for a good storage dir with self.assertRaises(ImproperlyConfigured): self.backend() def test_invalid_key_backslash(self): # Ensure we don't allow directory-traversal. # This is tested directly on _key_to_file, as load() will swallow # a SuspiciousOperation in the same way as an OSError - by creating # a new session, making it unclear whether the slashes were detected. with self.assertRaises(InvalidSessionKey): self.backend()._key_to_file("a\\b\\c") def test_invalid_key_forwardslash(self): # Ensure we don't allow directory-traversal with self.assertRaises(InvalidSessionKey): self.backend()._key_to_file("a/b/c") @override_settings( SESSION_ENGINE="django.contrib.sessions.backends.file", SESSION_COOKIE_AGE=0, ) def test_clearsessions_command(self): """ Test clearsessions command for clearing expired sessions. """ storage_path = self.backend._get_storage_path() file_prefix = settings.SESSION_COOKIE_NAME def count_sessions(): return len( [ session_file for session_file in os.listdir(storage_path) if session_file.startswith(file_prefix) ] ) self.assertEqual(0, count_sessions()) # One object in the future self.session["foo"] = "bar" self.session.set_expiry(3600) self.session.save() # One object in the past other_session = self.backend() other_session["foo"] = "bar" other_session.set_expiry(-3600) other_session.save() # One object in the present without an expiry (should be deleted since # its modification time + SESSION_COOKIE_AGE will be in the past when # clearsessions runs). other_session2 = self.backend() other_session2["foo"] = "bar" other_session2.save() # Three sessions are in the filesystem before clearsessions... self.assertEqual(3, count_sessions()) management.call_command("clearsessions") # ... and two are deleted. self.assertEqual(1, count_sessions()) class FileSessionPathLibTests(FileSessionTests): def mkdtemp(self): tmp_dir = super().mkdtemp() return Path(tmp_dir) class CacheSessionTests(SessionTestsMixin, SimpleTestCase): backend = CacheSession # Some backends might issue a warning @ignore_warnings(module="django.core.cache.backends.base") def test_load_overlong_key(self): self.session._session_key = (string.ascii_letters + string.digits) * 20 self.assertEqual(self.session.load(), {}) def test_default_cache(self): self.session.save() self.assertIsNotNone(caches["default"].get(self.session.cache_key)) @override_settings( CACHES={ "default": { "BACKEND": "django.core.cache.backends.dummy.DummyCache", }, "sessions": { "BACKEND": "django.core.cache.backends.locmem.LocMemCache", "LOCATION": "session", }, }, SESSION_CACHE_ALIAS="sessions", ) def test_non_default_cache(self): # Re-initialize the session backend to make use of overridden settings. self.session = self.backend() self.session.save() self.assertIsNone(caches["default"].get(self.session.cache_key)) self.assertIsNotNone(caches["sessions"].get(self.session.cache_key)) def test_create_and_save(self): self.session = self.backend() self.session.create() self.session.save() self.assertIsNotNone(caches["default"].get(self.session.cache_key)) class SessionMiddlewareTests(TestCase): request_factory = RequestFactory() @staticmethod def get_response_touching_session(request): request.session["hello"] = "world" return HttpResponse("Session test") @override_settings(SESSION_COOKIE_SECURE=True) def test_secure_session_cookie(self): request = self.request_factory.get("/") middleware = SessionMiddleware(self.get_response_touching_session) # Handle the response through the middleware response = middleware(request) self.assertIs(response.cookies[settings.SESSION_COOKIE_NAME]["secure"], True) @override_settings(SESSION_COOKIE_HTTPONLY=True) def test_httponly_session_cookie(self): request = self.request_factory.get("/") middleware = SessionMiddleware(self.get_response_touching_session) # Handle the response through the middleware response = middleware(request) self.assertIs(response.cookies[settings.SESSION_COOKIE_NAME]["httponly"], True) self.assertIn( cookies.Morsel._reserved["httponly"], str(response.cookies[settings.SESSION_COOKIE_NAME]), ) @override_settings(SESSION_COOKIE_SAMESITE="Strict") def test_samesite_session_cookie(self): request = self.request_factory.get("/") middleware = SessionMiddleware(self.get_response_touching_session) response = middleware(request) self.assertEqual( response.cookies[settings.SESSION_COOKIE_NAME]["samesite"], "Strict" ) @override_settings(SESSION_COOKIE_HTTPONLY=False) def test_no_httponly_session_cookie(self): request = self.request_factory.get("/") middleware = SessionMiddleware(self.get_response_touching_session) response = middleware(request) self.assertEqual(response.cookies[settings.SESSION_COOKIE_NAME]["httponly"], "") self.assertNotIn( cookies.Morsel._reserved["httponly"], str(response.cookies[settings.SESSION_COOKIE_NAME]), ) def test_session_save_on_500(self): def response_500(requset): response = HttpResponse("Horrible error") response.status_code = 500 request.session["hello"] = "world" return response request = self.request_factory.get("/") SessionMiddleware(response_500)(request) # The value wasn't saved above. self.assertNotIn("hello", request.session.load()) def test_session_update_error_redirect(self): def response_delete_session(request): request.session = DatabaseSession() request.session.save(must_create=True) request.session.delete() return HttpResponse() request = self.request_factory.get("/foo/") middleware = SessionMiddleware(response_delete_session) msg = ( "The request's session was deleted before the request completed. " "The user may have logged out in a concurrent request, for example." ) with self.assertRaisesMessage(SessionInterrupted, msg): # Handle the response through the middleware. It will try to save # the deleted session which will cause an UpdateError that's caught # and raised as a SessionInterrupted. middleware(request) def test_session_delete_on_end(self): def response_ending_session(request): request.session.flush() return HttpResponse("Session test") request = self.request_factory.get("/") middleware = SessionMiddleware(response_ending_session) # Before deleting, there has to be an existing cookie request.COOKIES[settings.SESSION_COOKIE_NAME] = "abc" # Handle the response through the middleware response = middleware(request) # The cookie was deleted, not recreated. # A deleted cookie header looks like: # "Set-Cookie: sessionid=; expires=Thu, 01 Jan 1970 00:00:00 GMT; " # "Max-Age=0; Path=/" self.assertEqual( 'Set-Cookie: {}=""; expires=Thu, 01 Jan 1970 00:00:00 GMT; ' "Max-Age=0; Path=/; SameSite={}".format( settings.SESSION_COOKIE_NAME, settings.SESSION_COOKIE_SAMESITE, ), str(response.cookies[settings.SESSION_COOKIE_NAME]), ) # SessionMiddleware sets 'Vary: Cookie' to prevent the 'Set-Cookie' # from being cached. self.assertEqual(response.headers["Vary"], "Cookie") @override_settings( SESSION_COOKIE_DOMAIN=".example.local", SESSION_COOKIE_PATH="/example/" ) def test_session_delete_on_end_with_custom_domain_and_path(self): def response_ending_session(request): request.session.flush() return HttpResponse("Session test") request = self.request_factory.get("/") middleware = SessionMiddleware(response_ending_session) # Before deleting, there has to be an existing cookie request.COOKIES[settings.SESSION_COOKIE_NAME] = "abc" # Handle the response through the middleware response = middleware(request) # The cookie was deleted, not recreated. # A deleted cookie header with a custom domain and path looks like: # Set-Cookie: sessionid=; Domain=.example.local; # expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; # Path=/example/ self.assertEqual( 'Set-Cookie: {}=""; Domain=.example.local; expires=Thu, ' "01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/example/; SameSite={}".format( settings.SESSION_COOKIE_NAME, settings.SESSION_COOKIE_SAMESITE, ), str(response.cookies[settings.SESSION_COOKIE_NAME]), ) def test_flush_empty_without_session_cookie_doesnt_set_cookie(self): def response_ending_session(request): request.session.flush() return HttpResponse("Session test") request = self.request_factory.get("/") middleware = SessionMiddleware(response_ending_session) # Handle the response through the middleware response = middleware(request) # A cookie should not be set. self.assertEqual(response.cookies, {}) # The session is accessed so "Vary: Cookie" should be set. self.assertEqual(response.headers["Vary"], "Cookie") def test_empty_session_saved(self): """ If a session is emptied of data but still has a key, it should still be updated. """ def response_set_session(request): # Set a session key and some data. request.session["foo"] = "bar" return HttpResponse("Session test") request = self.request_factory.get("/") middleware = SessionMiddleware(response_set_session) # Handle the response through the middleware. response = middleware(request) self.assertEqual(tuple(request.session.items()), (("foo", "bar"),)) # A cookie should be set, along with Vary: Cookie. self.assertIn( "Set-Cookie: sessionid=%s" % request.session.session_key, str(response.cookies), ) self.assertEqual(response.headers["Vary"], "Cookie") # Empty the session data. del request.session["foo"] # Handle the response through the middleware. response = HttpResponse("Session test") response = middleware.process_response(request, response) self.assertEqual(dict(request.session.values()), {}) session = Session.objects.get(session_key=request.session.session_key) self.assertEqual(session.get_decoded(), {}) # While the session is empty, it hasn't been flushed so a cookie should # still be set, along with Vary: Cookie. self.assertGreater(len(request.session.session_key), 8) self.assertIn( "Set-Cookie: sessionid=%s" % request.session.session_key, str(response.cookies), ) self.assertEqual(response.headers["Vary"], "Cookie") class CookieSessionTests(SessionTestsMixin, SimpleTestCase): backend = CookieSession def test_save(self): """ This test tested exists() in the other session backends, but that doesn't make sense for us. """ pass def test_cycle(self): """ This test tested cycle_key() which would create a new session key for the same session data. But we can't invalidate previously signed cookies (other than letting them expire naturally) so testing for this behavior is meaningless. """ pass @unittest.expectedFailure def test_actual_expiry(self): # The cookie backend doesn't handle non-default expiry dates, see #19201 super().test_actual_expiry() def test_unpickling_exception(self): # signed_cookies backend should handle unpickle exceptions gracefully # by creating a new session self.assertEqual(self.session.serializer, JSONSerializer) self.session.save() with mock.patch("django.core.signing.loads", side_effect=ValueError): self.session.load() @unittest.skip( "Cookie backend doesn't have an external store to create records in." ) def test_session_load_does_not_create_record(self): pass @unittest.skip( "CookieSession is stored in the client and there is no way to query it." ) def test_session_save_does_not_resurrect_session_logged_out_in_other_context(self): pass class ClearSessionsCommandTests(SimpleTestCase): def test_clearsessions_unsupported(self): msg = ( "Session engine 'tests.sessions_tests.no_clear_expired' doesn't " "support clearing expired sessions." ) with self.settings(SESSION_ENGINE="tests.sessions_tests.no_clear_expired"): with self.assertRaisesMessage(management.CommandError, msg): management.call_command("clearsessions")
0ad3c6811f9ca1af7cae2372aec856834833a95aec3b52757cad5e94e7b014a2
""" This custom Session model adds an extra column to store an account ID. In real-world applications, it gives you the option of querying the database for all active sessions for a particular account. """ from django.contrib.sessions.backends.db import SessionStore as DBStore from django.contrib.sessions.base_session import AbstractBaseSession from django.db import models class CustomSession(AbstractBaseSession): """ A session model with a column for an account ID. """ account_id = models.IntegerField(null=True, db_index=True) @classmethod def get_session_store_class(cls): return SessionStore class SessionStore(DBStore): """ A database session store, that handles updating the account ID column inside the custom session model. """ @classmethod def get_model_class(cls): return CustomSession def create_model_instance(self, data): obj = super().create_model_instance(data) try: account_id = int(data.get("_auth_user_id")) except (ValueError, TypeError): account_id = None obj.account_id = account_id return obj def get_session_cookie_age(self): return 60 * 60 * 24 # One day.
5055b6f5078c3acc16c27a7ac089d541cff92b4a41c4fdc18ce635956a8efa38
import unittest from unittest import mock from django.core.exceptions import ValidationError class TestValidationError(unittest.TestCase): def test_messages_concatenates_error_dict_values(self): message_dict = {} exception = ValidationError(message_dict) self.assertEqual(sorted(exception.messages), []) message_dict["field1"] = ["E1", "E2"] exception = ValidationError(message_dict) self.assertEqual(sorted(exception.messages), ["E1", "E2"]) message_dict["field2"] = ["E3", "E4"] exception = ValidationError(message_dict) self.assertEqual(sorted(exception.messages), ["E1", "E2", "E3", "E4"]) def test_eq(self): error1 = ValidationError("message") error2 = ValidationError("message", code="my_code1") error3 = ValidationError("message", code="my_code2") error4 = ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm1": "val1", "parm2": "val2"}, ) error5 = ValidationError({"field1": "message", "field2": "other"}) error6 = ValidationError({"field1": "message"}) error7 = ValidationError( [ ValidationError({"field1": "field error", "field2": "other"}), "message", ] ) self.assertEqual(error1, ValidationError("message")) self.assertNotEqual(error1, ValidationError("message2")) self.assertNotEqual(error1, error2) self.assertNotEqual(error1, error4) self.assertNotEqual(error1, error5) self.assertNotEqual(error1, error6) self.assertNotEqual(error1, error7) self.assertEqual(error1, mock.ANY) self.assertEqual(error2, ValidationError("message", code="my_code1")) self.assertNotEqual(error2, ValidationError("other", code="my_code1")) self.assertNotEqual(error2, error3) self.assertNotEqual(error2, error4) self.assertNotEqual(error2, error5) self.assertNotEqual(error2, error6) self.assertNotEqual(error2, error7) self.assertEqual( error4, ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm1": "val1", "parm2": "val2"}, ), ) self.assertNotEqual( error4, ValidationError( "error %(parm1)s %(parm2)s", code="my_code2", params={"parm1": "val1", "parm2": "val2"}, ), ) self.assertNotEqual( error4, ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val2"}, ), ) self.assertNotEqual( error4, ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val1", "parm1": "val2"}, ), ) self.assertNotEqual( error4, ValidationError( "error val1 val2", code="my_code1", ), ) # params ordering is ignored. self.assertEqual( error4, ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val2", "parm1": "val1"}, ), ) self.assertEqual( error5, ValidationError({"field1": "message", "field2": "other"}), ) self.assertNotEqual( error5, ValidationError({"field1": "message", "field2": "other2"}), ) self.assertNotEqual( error5, ValidationError({"field1": "message", "field3": "other"}), ) self.assertNotEqual(error5, error6) # fields ordering is ignored. self.assertEqual( error5, ValidationError({"field2": "other", "field1": "message"}), ) self.assertNotEqual(error7, ValidationError(error7.error_list[1:])) self.assertNotEqual( ValidationError(["message"]), ValidationError([ValidationError("message", code="my_code")]), ) # messages ordering is ignored. self.assertEqual( error7, ValidationError(list(reversed(error7.error_list))), ) self.assertNotEqual(error4, ValidationError([error4])) self.assertNotEqual(ValidationError([error4]), error4) self.assertNotEqual(error4, ValidationError({"field1": error4})) self.assertNotEqual(ValidationError({"field1": error4}), error4) def test_eq_nested(self): error_dict = { "field1": ValidationError( "error %(parm1)s %(parm2)s", code="my_code", params={"parm1": "val1", "parm2": "val2"}, ), "field2": "other", } error = ValidationError(error_dict) self.assertEqual(error, ValidationError(dict(error_dict))) self.assertEqual( error, ValidationError( { "field1": ValidationError( "error %(parm1)s %(parm2)s", code="my_code", params={"parm2": "val2", "parm1": "val1"}, ), "field2": "other", } ), ) self.assertNotEqual( error, ValidationError( {**error_dict, "field2": "message"}, ), ) self.assertNotEqual( error, ValidationError( { "field1": ValidationError( "error %(parm1)s val2", code="my_code", params={"parm1": "val1"}, ), "field2": "other", } ), ) def test_hash(self): error1 = ValidationError("message") error2 = ValidationError("message", code="my_code1") error3 = ValidationError("message", code="my_code2") error4 = ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm1": "val1", "parm2": "val2"}, ) error5 = ValidationError({"field1": "message", "field2": "other"}) error6 = ValidationError({"field1": "message"}) error7 = ValidationError( [ ValidationError({"field1": "field error", "field2": "other"}), "message", ] ) self.assertEqual(hash(error1), hash(ValidationError("message"))) self.assertNotEqual(hash(error1), hash(ValidationError("message2"))) self.assertNotEqual(hash(error1), hash(error2)) self.assertNotEqual(hash(error1), hash(error4)) self.assertNotEqual(hash(error1), hash(error5)) self.assertNotEqual(hash(error1), hash(error6)) self.assertNotEqual(hash(error1), hash(error7)) self.assertEqual( hash(error2), hash(ValidationError("message", code="my_code1")), ) self.assertNotEqual( hash(error2), hash(ValidationError("other", code="my_code1")), ) self.assertNotEqual(hash(error2), hash(error3)) self.assertNotEqual(hash(error2), hash(error4)) self.assertNotEqual(hash(error2), hash(error5)) self.assertNotEqual(hash(error2), hash(error6)) self.assertNotEqual(hash(error2), hash(error7)) self.assertEqual( hash(error4), hash( ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm1": "val1", "parm2": "val2"}, ) ), ) self.assertNotEqual( hash(error4), hash( ValidationError( "error %(parm1)s %(parm2)s", code="my_code2", params={"parm1": "val1", "parm2": "val2"}, ) ), ) self.assertNotEqual( hash(error4), hash( ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val2"}, ) ), ) self.assertNotEqual( hash(error4), hash( ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val1", "parm1": "val2"}, ) ), ) self.assertNotEqual( hash(error4), hash( ValidationError( "error val1 val2", code="my_code1", ) ), ) # params ordering is ignored. self.assertEqual( hash(error4), hash( ValidationError( "error %(parm1)s %(parm2)s", code="my_code1", params={"parm2": "val2", "parm1": "val1"}, ) ), ) self.assertEqual( hash(error5), hash(ValidationError({"field1": "message", "field2": "other"})), ) self.assertNotEqual( hash(error5), hash(ValidationError({"field1": "message", "field2": "other2"})), ) self.assertNotEqual( hash(error5), hash(ValidationError({"field1": "message", "field3": "other"})), ) self.assertNotEqual(error5, error6) # fields ordering is ignored. self.assertEqual( hash(error5), hash(ValidationError({"field2": "other", "field1": "message"})), ) self.assertNotEqual( hash(error7), hash(ValidationError(error7.error_list[1:])), ) self.assertNotEqual( hash(ValidationError(["message"])), hash(ValidationError([ValidationError("message", code="my_code")])), ) # messages ordering is ignored. self.assertEqual( hash(error7), hash(ValidationError(list(reversed(error7.error_list)))), ) self.assertNotEqual(hash(error4), hash(ValidationError([error4]))) self.assertNotEqual(hash(ValidationError([error4])), hash(error4)) self.assertNotEqual( hash(error4), hash(ValidationError({"field1": error4})), ) def test_hash_nested(self): error_dict = { "field1": ValidationError( "error %(parm1)s %(parm2)s", code="my_code", params={"parm2": "val2", "parm1": "val1"}, ), "field2": "other", } error = ValidationError(error_dict) self.assertEqual(hash(error), hash(ValidationError(dict(error_dict)))) self.assertEqual( hash(error), hash( ValidationError( { "field1": ValidationError( "error %(parm1)s %(parm2)s", code="my_code", params={"parm1": "val1", "parm2": "val2"}, ), "field2": "other", } ) ), ) self.assertNotEqual( hash(error), hash( ValidationError( {**error_dict, "field2": "message"}, ) ), ) self.assertNotEqual( hash(error), hash( ValidationError( { "field1": ValidationError( "error %(parm1)s val2", code="my_code", params={"parm1": "val1"}, ), "field2": "other", } ) ), )
ea432f080e65e84e910ae64b0b2bf22f06a0168652bcd44748c51899be69dae2
from datetime import datetime from django.contrib.sitemaps import GenericSitemap from django.test import ignore_warnings, override_settings from django.utils.deprecation import RemovedInDjango50Warning from .base import SitemapTestsBase from .models import TestModel @override_settings(ABSOLUTE_URL_OVERRIDES={}) class GenericViewsSitemapTests(SitemapTestsBase): def test_generic_sitemap_attributes(self): datetime_value = datetime.now() queryset = TestModel.objects.all() generic_sitemap = GenericSitemap( info_dict={ "queryset": queryset, "date_field": datetime_value, }, priority=0.6, changefreq="monthly", protocol="https", ) attr_values = ( ("date_field", datetime_value), ("priority", 0.6), ("changefreq", "monthly"), ("protocol", "https"), ) for attr_name, expected_value in attr_values: with self.subTest(attr_name=attr_name): self.assertEqual(getattr(generic_sitemap, attr_name), expected_value) self.assertCountEqual(generic_sitemap.queryset, queryset) def test_generic_sitemap(self): "A minimal generic sitemap can be rendered" response = self.client.get("/generic/sitemap.xml") expected = "" for pk in TestModel.objects.values_list("id", flat=True): expected += "<url><loc>%s/testmodel/%s/</loc></url>" % (self.base_url, pk) expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "%s\n" "</urlset>" ) % expected self.assertXMLEqual(response.content.decode(), expected_content) def test_generic_sitemap_lastmod(self): test_model = TestModel.objects.first() TestModel.objects.update(lastmod=datetime(2013, 3, 13, 10, 0, 0)) response = self.client.get("/generic-lastmod/sitemap.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>%s/testmodel/%s/</loc><lastmod>2013-03-13</lastmod></url>\n" "</urlset>" ) % ( self.base_url, test_model.pk, ) self.assertXMLEqual(response.content.decode(), expected_content) self.assertEqual( response.headers["Last-Modified"], "Wed, 13 Mar 2013 10:00:00 GMT" ) def test_get_protocol_defined_in_constructor(self): for protocol in ["http", "https"]: with self.subTest(protocol=protocol): sitemap = GenericSitemap({"queryset": None}, protocol=protocol) self.assertEqual(sitemap.get_protocol(), protocol) def test_get_protocol_passed_as_argument(self): sitemap = GenericSitemap({"queryset": None}) for protocol in ["http", "https"]: with self.subTest(protocol=protocol): self.assertEqual(sitemap.get_protocol(protocol), protocol) @ignore_warnings(category=RemovedInDjango50Warning) def test_get_protocol_default(self): sitemap = GenericSitemap({"queryset": None}) self.assertEqual(sitemap.get_protocol(), "http") def test_get_protocol_default_warning(self): sitemap = GenericSitemap({"queryset": None}) msg = ( "The default sitemap protocol will be changed from 'http' to " "'https' in Django 5.0. Set Sitemap.protocol to silence this " "warning." ) with self.assertWarnsMessage(RemovedInDjango50Warning, msg): sitemap.get_protocol() def test_generic_sitemap_index(self): TestModel.objects.update(lastmod=datetime(2013, 3, 13, 10, 0, 0)) response = self.client.get("/generic-lastmod/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>http://example.com/simple/sitemap-generic.xml</loc><lastmod>2013-03-13T10:00:00</lastmod></sitemap> </sitemapindex>""" self.assertXMLEqual(response.content.decode("utf-8"), expected_content)
1207cd73e47b2445c143c817b2850aadba4ce8c2ec66d7810e7fa10d4bd9bb67
from unittest import mock from urllib.parse import urlencode from django.contrib.sitemaps import SitemapNotFound, _get_sitemap_full_url, ping_google from django.core.exceptions import ImproperlyConfigured from django.test import modify_settings, override_settings from .base import SitemapTestsBase class PingGoogleTests(SitemapTestsBase): @override_settings(ROOT_URLCONF="sitemaps_tests.urls.sitemap_only") @mock.patch("django.contrib.sitemaps.urlopen") def test_something(self, urlopen): ping_google() params = urlencode( {"sitemap": "https://example.com/sitemap-without-entries/sitemap.xml"} ) full_url = "https://www.google.com/webmasters/tools/ping?%s" % params urlopen.assert_called_with(full_url) @override_settings(ROOT_URLCONF="sitemaps_tests.urls.sitemap_only") def test_get_sitemap_full_url_global(self): self.assertEqual( _get_sitemap_full_url(None), "https://example.com/sitemap-without-entries/sitemap.xml", ) @override_settings(ROOT_URLCONF="sitemaps_tests.urls.index_only") def test_get_sitemap_full_url_index(self): self.assertEqual( _get_sitemap_full_url(None), "https://example.com/simple/index.xml" ) @override_settings(ROOT_URLCONF="sitemaps_tests.urls.empty") def test_get_sitemap_full_url_not_detected(self): msg = ( "You didn't provide a sitemap_url, and the sitemap URL couldn't be " "auto-detected." ) with self.assertRaisesMessage(SitemapNotFound, msg): _get_sitemap_full_url(None) def test_get_sitemap_full_url_exact_url(self): self.assertEqual( _get_sitemap_full_url("/foo.xml"), "https://example.com/foo.xml" ) def test_get_sitemap_full_url_insecure(self): self.assertEqual( _get_sitemap_full_url("/foo.xml", sitemap_uses_https=False), "http://example.com/foo.xml", ) @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"}) def test_get_sitemap_full_url_no_sites(self): msg = "ping_google requires django.contrib.sites, which isn't installed." with self.assertRaisesMessage(ImproperlyConfigured, msg): _get_sitemap_full_url(None)
24e7421b2e394424ce426c02ab85d9710163a4750567480415125653c1e35f0f
from datetime import date from django.test import override_settings from .base import SitemapTestsBase @override_settings(ROOT_URLCONF="sitemaps_tests.urls.https") class HTTPSSitemapTests(SitemapTestsBase): protocol = "https" def test_secure_sitemap_index(self): "A secure sitemap index can be rendered" response = self.client.get("/secure/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/secure/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_secure_sitemap_section(self): "A secure sitemap section can be rendered" response = self.client.get("/secure/sitemap-simple.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>%s/location/</loc><lastmod>%s</lastmod>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ) % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings(SECURE_PROXY_SSL_HEADER=False) class HTTPSDetectionSitemapTests(SitemapTestsBase): extra = {"wsgi.url_scheme": "https"} def test_sitemap_index_with_https_request(self): "A sitemap index requested in HTTPS is rendered with HTTPS links" response = self.client.get("/simple/index.xml", **self.extra) expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/simple/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url.replace("http://", "https://"), date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_sitemap_section_with_https_request(self): "A sitemap section requested in HTTPS is rendered with HTTPS links" response = self.client.get("/simple/sitemap-simple.xml", **self.extra) expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>%s/location/</loc><lastmod>%s</lastmod>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ) % ( self.base_url.replace("http://", "https://"), date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content)
b47f00595a3b6c8b1eb5da10b877c69889b215218bec398af9edb0d83a8f9d26
from django.db import models from django.urls import reverse class TestModel(models.Model): name = models.CharField(max_length=100) lastmod = models.DateTimeField(null=True) def get_absolute_url(self): return "/testmodel/%s/" % self.id class I18nTestModel(models.Model): name = models.CharField(max_length=100) def get_absolute_url(self): return reverse("i18n_testmodel", args=[self.id])
a4d41b821cf9653631f60fc85514325211995c9286c81f56d387dd047c1eca0e
from unittest import mock from django.core.management import call_command from .base import SitemapTestsBase @mock.patch("django.contrib.sitemaps.management.commands.ping_google.ping_google") class PingGoogleTests(SitemapTestsBase): def test_default(self, ping_google_func): call_command("ping_google") ping_google_func.assert_called_with(sitemap_url=None, sitemap_uses_https=True) def test_args(self, ping_google_func): call_command("ping_google", "foo.xml", "--sitemap-uses-http") ping_google_func.assert_called_with( sitemap_url="foo.xml", sitemap_uses_https=False )
7195dcf93f242d391c59a591a3b8ef8ca7fbf78696ac9e170e9246f72f77ad30
from django.apps import apps from django.contrib.sites.models import Site from django.core.cache import cache from django.test import TestCase, modify_settings, override_settings from .models import I18nTestModel, TestModel @modify_settings(INSTALLED_APPS={"append": "django.contrib.sitemaps"}) @override_settings(ROOT_URLCONF="sitemaps_tests.urls.http") class SitemapTestsBase(TestCase): protocol = "http" sites_installed = apps.is_installed("django.contrib.sites") domain = "example.com" if sites_installed else "testserver" @classmethod def setUpTestData(cls): # Create an object for sitemap content. TestModel.objects.create(name="Test Object") cls.i18n_model = I18nTestModel.objects.create(name="Test Object") def setUp(self): self.base_url = "%s://%s" % (self.protocol, self.domain) cache.clear() @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()
bd2a7ea274e94e79f846a2dffc3e9be66b6e8806a674374f7fb2e5885698032f
import os from datetime import date from django.contrib.sitemaps import Sitemap from django.contrib.sites.models import Site from django.core.exceptions import ImproperlyConfigured from django.test import ignore_warnings, modify_settings, override_settings from django.utils import translation from django.utils.deprecation import RemovedInDjango50Warning from django.utils.formats import localize from .base import SitemapTestsBase from .models import TestModel class HTTPSitemapTests(SitemapTestsBase): use_sitemap_err_msg = ( "To use sitemaps, either enable the sites framework or pass a " "Site/RequestSite object in your view." ) def test_simple_sitemap_index(self): "A simple sitemap index can be rendered" response = self.client.get("/simple/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/simple/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_sitemap_not_callable(self): """A sitemap may not be callable.""" response = self.client.get("/simple-not-callable/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/simple/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_paged_sitemap(self): """A sitemap may have multiple pages.""" response = self.client.get("/simple-paged/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>{0}/simple/sitemap-simple.xml</loc><lastmod>{1}</lastmod></sitemap><sitemap><loc>{0}/simple/sitemap-simple.xml?p=2</loc><lastmod>{1}</lastmod></sitemap> </sitemapindex> """.format( self.base_url, date.today() ) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings( TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [os.path.join(os.path.dirname(__file__), "templates")], } ] ) def test_simple_sitemap_custom_lastmod_index(self): "A simple sitemap index can be rendered with a custom template" response = self.client.get("/simple/custom-lastmod-index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <!-- This is a customised template --> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/simple/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_simple_sitemap_section(self): "A simple sitemap section can be rendered" response = self.client.get("/simple/sitemap-simple.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>%s/location/</loc><lastmod>%s</lastmod>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ) % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_no_section(self): response = self.client.get("/simple/sitemap-simple2.xml") self.assertEqual( str(response.context["exception"]), "No sitemap available for section: 'simple2'", ) self.assertEqual(response.status_code, 404) def test_empty_page(self): response = self.client.get("/simple/sitemap-simple.xml?p=0") self.assertEqual(str(response.context["exception"]), "Page 0 empty") self.assertEqual(response.status_code, 404) def test_page_not_int(self): response = self.client.get("/simple/sitemap-simple.xml?p=test") self.assertEqual(str(response.context["exception"]), "No page 'test'") self.assertEqual(response.status_code, 404) def test_simple_sitemap(self): "A simple sitemap can be rendered" response = self.client.get("/simple/sitemap.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>%s/location/</loc><lastmod>%s</lastmod>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ) % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings( TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [os.path.join(os.path.dirname(__file__), "templates")], } ] ) def test_simple_custom_sitemap(self): "A simple sitemap can be rendered with a custom template" response = self.client.get("/simple/custom-sitemap.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <!-- This is a customised template --> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url> </urlset> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_sitemap_last_modified(self): "Last-Modified header is set correctly" response = self.client.get("/lastmod/sitemap.xml") self.assertEqual( response.headers["Last-Modified"], "Wed, 13 Mar 2013 10:00:00 GMT" ) def test_sitemap_last_modified_date(self): """ The Last-Modified header should be support dates (without time). """ response = self.client.get("/lastmod/date-sitemap.xml") self.assertEqual( response.headers["Last-Modified"], "Wed, 13 Mar 2013 00:00:00 GMT" ) def test_sitemap_last_modified_tz(self): """ The Last-Modified header should be converted from timezone aware dates to GMT. """ response = self.client.get("/lastmod/tz-sitemap.xml") self.assertEqual( response.headers["Last-Modified"], "Wed, 13 Mar 2013 15:00:00 GMT" ) def test_sitemap_last_modified_missing(self): "Last-Modified header is missing when sitemap has no lastmod" response = self.client.get("/generic/sitemap.xml") self.assertFalse(response.has_header("Last-Modified")) def test_sitemap_last_modified_mixed(self): "Last-Modified header is omitted when lastmod not on all items" response = self.client.get("/lastmod-mixed/sitemap.xml") self.assertFalse(response.has_header("Last-Modified")) def test_sitemaps_lastmod_mixed_ascending_last_modified_missing(self): """ The Last-Modified header is omitted when lastmod isn't found in all sitemaps. Test sitemaps are sorted by lastmod in ascending order. """ response = self.client.get("/lastmod-sitemaps/mixed-ascending.xml") self.assertFalse(response.has_header("Last-Modified")) def test_sitemaps_lastmod_mixed_descending_last_modified_missing(self): """ The Last-Modified header is omitted when lastmod isn't found in all sitemaps. Test sitemaps are sorted by lastmod in descending order. """ response = self.client.get("/lastmod-sitemaps/mixed-descending.xml") self.assertFalse(response.has_header("Last-Modified")) def test_sitemaps_lastmod_ascending(self): """ The Last-Modified header is set to the most recent sitemap lastmod. Test sitemaps are sorted by lastmod in ascending order. """ response = self.client.get("/lastmod-sitemaps/ascending.xml") self.assertEqual( response.headers["Last-Modified"], "Sat, 20 Apr 2013 05:00:00 GMT" ) def test_sitemaps_lastmod_descending(self): """ The Last-Modified header is set to the most recent sitemap lastmod. Test sitemaps are sorted by lastmod in descending order. """ response = self.client.get("/lastmod-sitemaps/descending.xml") self.assertEqual( response.headers["Last-Modified"], "Sat, 20 Apr 2013 05:00:00 GMT" ) def test_sitemap_get_latest_lastmod_none(self): """ sitemapindex.lastmod is ommitted when Sitemap.lastmod is callable and Sitemap.get_latest_lastmod is not implemented """ response = self.client.get("/lastmod/get-latest-lastmod-none-sitemap.xml") self.assertNotContains(response, "<lastmod>") def test_sitemap_get_latest_lastmod(self): """ sitemapindex.lastmod is included when Sitemap.lastmod is attribute and Sitemap.get_latest_lastmod is implemented """ response = self.client.get("/lastmod/get-latest-lastmod-sitemap.xml") self.assertContains(response, "<lastmod>2013-03-13T10:00:00</lastmod>") def test_sitemap_latest_lastmod_timezone(self): """ lastmod datestamp shows timezones if Sitemap.get_latest_lastmod returns an aware datetime. """ response = self.client.get("/lastmod/latest-lastmod-timezone-sitemap.xml") self.assertContains(response, "<lastmod>2013-03-13T10:00:00-05:00</lastmod>") def test_localized_priority(self): """The priority value should not be localized.""" with translation.override("fr"): self.assertEqual("0,3", localize(0.3)) # Priorities aren't rendered in localized format. response = self.client.get("/simple/sitemap.xml") self.assertContains(response, "<priority>0.5</priority>") self.assertContains(response, "<lastmod>%s</lastmod>" % date.today()) @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"}) def test_requestsite_sitemap(self): # Hitting the flatpages sitemap without the sites framework installed # doesn't raise an exception. response = self.client.get("/simple/sitemap.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>http://testserver/location/</loc><lastmod>%s</lastmod>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ) % date.today() self.assertXMLEqual(response.content.decode(), expected_content) @ignore_warnings(category=RemovedInDjango50Warning) def test_sitemap_get_urls_no_site_1(self): """ Check we get ImproperlyConfigured if we don't pass a site object to Sitemap.get_urls and no Site objects exist """ Site.objects.all().delete() with self.assertRaisesMessage(ImproperlyConfigured, self.use_sitemap_err_msg): Sitemap().get_urls() @modify_settings(INSTALLED_APPS={"remove": "django.contrib.sites"}) @ignore_warnings(category=RemovedInDjango50Warning) def test_sitemap_get_urls_no_site_2(self): """ Check we get ImproperlyConfigured when we don't pass a site object to Sitemap.get_urls if Site objects exists, but the sites framework is not actually installed. """ with self.assertRaisesMessage(ImproperlyConfigured, self.use_sitemap_err_msg): Sitemap().get_urls() @ignore_warnings(category=RemovedInDjango50Warning) def test_sitemap_item(self): """ Check to make sure that the raw item is included with each Sitemap.get_url() url result. """ test_sitemap = Sitemap() test_sitemap.items = TestModel.objects.order_by("pk").all def is_testmodel(url): return isinstance(url["item"], TestModel) item_in_url_info = all(map(is_testmodel, test_sitemap.get_urls())) self.assertTrue(item_in_url_info) def test_cached_sitemap_index(self): """ A cached sitemap index can be rendered (#2713). """ response = self.client.get("/cached/index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/cached/sitemap-simple.xml</loc><lastmod>%s</lastmod></sitemap> </sitemapindex> """ % ( self.base_url, date.today(), ) self.assertXMLEqual(response.content.decode(), expected_content) def test_x_robots_sitemap(self): response = self.client.get("/simple/index.xml") self.assertEqual(response.headers["X-Robots-Tag"], "noindex, noodp, noarchive") response = self.client.get("/simple/sitemap.xml") self.assertEqual(response.headers["X-Robots-Tag"], "noindex, noodp, noarchive") def test_empty_sitemap(self): response = self.client.get("/empty/sitemap.xml") self.assertEqual(response.status_code, 200) @override_settings(LANGUAGES=(("en", "English"), ("pt", "Portuguese"))) def test_simple_i18n_sitemap_index(self): """ A simple i18n sitemap index can be rendered, without logging variable lookup errors. """ with self.assertNoLogs("django.template", "DEBUG"): response = self.client.get("/simple/i18n.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>{0}/en/i18n/testmodel/{1}/</loc><changefreq>never</changefreq>" "<priority>0.5</priority></url><url><loc>{0}/pt/i18n/testmodel/{1}/</loc>" "<changefreq>never</changefreq><priority>0.5</priority></url>\n" "</urlset>" ).format(self.base_url, self.i18n_model.pk) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings(LANGUAGES=(("en", "English"), ("pt", "Portuguese"))) def test_alternate_i18n_sitemap_index(self): """ A i18n sitemap with alternate/hreflang links can be rendered. """ response = self.client.get("/alternates/i18n.xml") url, pk = self.base_url, self.i18n_model.pk expected_urls = f""" <url><loc>{url}/en/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="pt" href="{url}/pt/i18n/testmodel/{pk}/"/> </url> <url><loc>{url}/pt/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="pt" href="{url}/pt/i18n/testmodel/{pk}/"/> </url> """.replace( "\n", "" ) expected_content = ( f'<?xml version="1.0" encoding="UTF-8"?>\n' f'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' f'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' f"{expected_urls}\n" f"</urlset>" ) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings( LANGUAGES=(("en", "English"), ("pt", "Portuguese"), ("es", "Spanish")) ) def test_alternate_i18n_sitemap_limited(self): """ A i18n sitemap index with limited languages can be rendered. """ response = self.client.get("/limited/i18n.xml") url, pk = self.base_url, self.i18n_model.pk expected_urls = f""" <url><loc>{url}/en/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="es" href="{url}/es/i18n/testmodel/{pk}/"/> </url> <url><loc>{url}/es/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="es" href="{url}/es/i18n/testmodel/{pk}/"/> </url> """.replace( "\n", "" ) expected_content = ( f'<?xml version="1.0" encoding="UTF-8"?>\n' f'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' f'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' f"{expected_urls}\n" f"</urlset>" ) self.assertXMLEqual(response.content.decode(), expected_content) @override_settings(LANGUAGES=(("en", "English"), ("pt", "Portuguese"))) def test_alternate_i18n_sitemap_xdefault(self): """ A i18n sitemap index with x-default can be rendered. """ response = self.client.get("/x-default/i18n.xml") url, pk = self.base_url, self.i18n_model.pk expected_urls = f""" <url><loc>{url}/en/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="pt" href="{url}/pt/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="x-default" href="{url}/i18n/testmodel/{pk}/"/> </url> <url><loc>{url}/pt/i18n/testmodel/{pk}/</loc><changefreq>never</changefreq><priority>0.5</priority> <xhtml:link rel="alternate" hreflang="en" href="{url}/en/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="pt" href="{url}/pt/i18n/testmodel/{pk}/"/> <xhtml:link rel="alternate" hreflang="x-default" href="{url}/i18n/testmodel/{pk}/"/> </url> """.replace( "\n", "" ) expected_content = ( f'<?xml version="1.0" encoding="UTF-8"?>\n' f'<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' f'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' f"{expected_urls}\n" f"</urlset>" ) self.assertXMLEqual(response.content.decode(), expected_content) def test_sitemap_without_entries(self): response = self.client.get("/sitemap-without-entries/sitemap.xml") expected_content = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n\n' "</urlset>" ) self.assertXMLEqual(response.content.decode(), expected_content) def test_callable_sitemod_partial(self): """ Not all items have `lastmod`. Therefore the `Last-Modified` header is not set by the detail or index sitemap view. """ index_response = self.client.get("/callable-lastmod-partial/index.xml") sitemap_response = self.client.get("/callable-lastmod-partial/sitemap.xml") self.assertNotIn("Last-Modified", index_response) self.assertNotIn("Last-Modified", sitemap_response) expected_content_index = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>http://example.com/simple/sitemap-callable-lastmod.xml</loc></sitemap> </sitemapindex> """ expected_content_sitemap = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>http://example.com/location/</loc>" "<lastmod>2013-03-13</lastmod></url><url>" "<loc>http://example.com/location/</loc></url>\n" "</urlset>" ) self.assertXMLEqual(index_response.content.decode(), expected_content_index) self.assertXMLEqual(sitemap_response.content.decode(), expected_content_sitemap) def test_callable_sitemod_full(self): """ All items in the sitemap have `lastmod`. The `Last-Modified` header is set for the detail and index sitemap view. """ index_response = self.client.get("/callable-lastmod-full/index.xml") sitemap_response = self.client.get("/callable-lastmod-full/sitemap.xml") self.assertEqual( index_response.headers["Last-Modified"], "Thu, 13 Mar 2014 10:00:00 GMT" ) self.assertEqual( sitemap_response.headers["Last-Modified"], "Thu, 13 Mar 2014 10:00:00 GMT" ) expected_content_index = """<?xml version="1.0" encoding="UTF-8"?> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>http://example.com/simple/sitemap-callable-lastmod.xml</loc><lastmod>2014-03-13T10:00:00</lastmod></sitemap> </sitemapindex> """ expected_content_sitemap = ( '<?xml version="1.0" encoding="UTF-8"?>\n' '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" ' 'xmlns:xhtml="http://www.w3.org/1999/xhtml">\n' "<url><loc>http://example.com/location/</loc>" "<lastmod>2013-03-13</lastmod></url>" "<url><loc>http://example.com/location/</loc>" "<lastmod>2014-03-13</lastmod></url>\n" "</urlset>" ) self.assertXMLEqual(index_response.content.decode(), expected_content_index) self.assertXMLEqual(sitemap_response.content.decode(), expected_content_sitemap) # RemovedInDjango50Warning class DeprecatedTests(SitemapTestsBase): @override_settings( TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [os.path.join(os.path.dirname(__file__), "templates")], } ] ) def test_simple_sitemap_custom_index_warning(self): msg = ( "Calling `__str__` on SitemapIndexItem is deprecated, use the `location` " "attribute instead." ) with self.assertRaisesMessage(RemovedInDjango50Warning, msg): self.client.get("/simple/custom-index.xml") @ignore_warnings(category=RemovedInDjango50Warning) @override_settings( TEMPLATES=[ { "BACKEND": "django.template.backends.django.DjangoTemplates", "DIRS": [os.path.join(os.path.dirname(__file__), "templates")], } ] ) def test_simple_sitemap_custom_index(self): "A simple sitemap index can be rendered with a custom template" response = self.client.get("/simple/custom-index.xml") expected_content = """<?xml version="1.0" encoding="UTF-8"?> <!-- This is a customised template --> <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap> </sitemapindex> """ % ( self.base_url ) self.assertXMLEqual(response.content.decode(), expected_content)
b72bf23e6264af90d18113d3413d6979e3f41a965c07013b877f89a031d377a7
from django.core.exceptions import FieldError from django.test import TestCase from .models import Choice, Inner, OuterA, OuterB, Poll class NullQueriesTests(TestCase): def test_none_as_null(self): """ Regression test for the use of None as a query value. None is interpreted as an SQL NULL, but only in __exact and __iexact queries. Set up some initial polls and choices """ p1 = Poll(question="Why?") p1.save() c1 = Choice(poll=p1, choice="Because.") c1.save() c2 = Choice(poll=p1, choice="Why Not?") c2.save() # Exact query with value None returns nothing ("is NULL" in sql, # but every 'id' field has a value). self.assertSequenceEqual(Choice.objects.filter(choice__exact=None), []) # The same behavior for iexact query. self.assertSequenceEqual(Choice.objects.filter(choice__iexact=None), []) # Excluding the previous result returns everything. self.assertSequenceEqual( Choice.objects.exclude(choice=None).order_by("id"), [c1, c2] ) # Valid query, but fails because foo isn't a keyword msg = ( "Cannot resolve keyword 'foo' into field. Choices are: choice, id, poll, " "poll_id" ) with self.assertRaisesMessage(FieldError, msg): Choice.objects.filter(foo__exact=None) # Can't use None on anything other than __exact and __iexact with self.assertRaisesMessage(ValueError, "Cannot use None as a query value"): Choice.objects.filter(id__gt=None) def test_unsaved(self): poll = Poll(question="How?") msg = ( "'Poll' instance needs to have a primary key value before this " "relationship can be used." ) with self.assertRaisesMessage(ValueError, msg): poll.choice_set.all() def test_reverse_relations(self): """ Querying across reverse relations and then another relation should insert outer joins correctly so as not to exclude results. """ obj = OuterA.objects.create() self.assertSequenceEqual(OuterA.objects.filter(inner__third=None), [obj]) self.assertSequenceEqual(OuterA.objects.filter(inner__third__data=None), [obj]) inner = Inner.objects.create(first=obj) self.assertSequenceEqual( Inner.objects.filter(first__inner__third=None), [inner] ) # Ticket #13815: check if <reverse>_isnull=False does not produce # faulty empty lists outerb = OuterB.objects.create(data="reverse") self.assertSequenceEqual(OuterB.objects.filter(inner__isnull=False), []) Inner.objects.create(first=obj) self.assertSequenceEqual(OuterB.objects.exclude(inner__isnull=False), [outerb])
3b5d1e4ed5c45847817e2c4ff7ed4c85c52fd64bcd03afedd7383fd1aa9d2646
from django.db import models class Poll(models.Model): question = models.CharField(max_length=200) class Choice(models.Model): poll = models.ForeignKey(Poll, models.CASCADE) choice = models.CharField(max_length=200) # A set of models with an inner one pointing to two outer ones. class OuterA(models.Model): pass class OuterB(models.Model): data = models.CharField(max_length=10) class Inner(models.Model): first = models.ForeignKey(OuterA, models.CASCADE) # second would clash with the __second lookup. third = models.ForeignKey(OuterB, models.SET_NULL, null=True)
0ad03f1af30140f16a6bc618777afe1fcd8576828467fe531d5edfe69333f238
"""Tests for django.db.utils.""" import unittest from django.core.exceptions import ImproperlyConfigured from django.db import DEFAULT_DB_ALIAS, ProgrammingError, connection from django.db.utils import ConnectionHandler, load_backend from django.test import SimpleTestCase, TestCase from django.utils.connection import ConnectionDoesNotExist class ConnectionHandlerTests(SimpleTestCase): def test_connection_handler_no_databases(self): """ Empty DATABASES and empty 'default' settings default to the dummy backend. """ for DATABASES in ( {}, # Empty DATABASES setting. {"default": {}}, # Empty 'default' database. ): with self.subTest(DATABASES=DATABASES): self.assertImproperlyConfigured(DATABASES) def assertImproperlyConfigured(self, DATABASES): conns = ConnectionHandler(DATABASES) self.assertEqual( conns[DEFAULT_DB_ALIAS].settings_dict["ENGINE"], "django.db.backends.dummy" ) msg = ( "settings.DATABASES is improperly configured. Please supply the " "ENGINE value. Check settings documentation for more details." ) with self.assertRaisesMessage(ImproperlyConfigured, msg): conns[DEFAULT_DB_ALIAS].ensure_connection() def test_no_default_database(self): DATABASES = {"other": {}} conns = ConnectionHandler(DATABASES) msg = "You must define a 'default' database." with self.assertRaisesMessage(ImproperlyConfigured, msg): conns["other"].ensure_connection() def test_nonexistent_alias(self): msg = "The connection 'nonexistent' doesn't exist." conns = ConnectionHandler( { DEFAULT_DB_ALIAS: {"ENGINE": "django.db.backends.dummy"}, } ) with self.assertRaisesMessage(ConnectionDoesNotExist, msg): conns["nonexistent"] def test_ensure_defaults_nonexistent_alias(self): msg = "The connection 'nonexistent' doesn't exist." conns = ConnectionHandler( { DEFAULT_DB_ALIAS: {"ENGINE": "django.db.backends.dummy"}, } ) with self.assertRaisesMessage(ConnectionDoesNotExist, msg): conns.ensure_defaults("nonexistent") def test_prepare_test_settings_nonexistent_alias(self): msg = "The connection 'nonexistent' doesn't exist." conns = ConnectionHandler( { DEFAULT_DB_ALIAS: {"ENGINE": "django.db.backends.dummy"}, } ) with self.assertRaisesMessage(ConnectionDoesNotExist, msg): conns.prepare_test_settings("nonexistent") class DatabaseErrorWrapperTests(TestCase): @unittest.skipUnless(connection.vendor == "postgresql", "PostgreSQL test") def test_reraising_backend_specific_database_exception(self): with connection.cursor() as cursor: msg = 'table "X" does not exist' with self.assertRaisesMessage(ProgrammingError, msg) as cm: cursor.execute('DROP TABLE "X"') self.assertNotEqual(type(cm.exception), type(cm.exception.__cause__)) self.assertIsNotNone(cm.exception.__cause__) self.assertIsNotNone(cm.exception.__cause__.pgcode) self.assertIsNotNone(cm.exception.__cause__.pgerror) class LoadBackendTests(SimpleTestCase): def test_load_backend_invalid_name(self): msg = ( "'foo' isn't an available database backend or couldn't be " "imported. Check the above exception. To use one of the built-in " "backends, use 'django.db.backends.XXX', where XXX is one of:\n" " 'mysql', 'oracle', 'postgresql', 'sqlite3'" ) with self.assertRaisesMessage(ImproperlyConfigured, msg) as cm: load_backend("foo") self.assertEqual(str(cm.exception.__cause__), "No module named 'foo'")
1147383243325c62ef86976af3c647429b9d21b3fb78d0887f3ea7bfeae3236a
from django.db.models import Q from django.http import Http404 from django.shortcuts import get_list_or_404, get_object_or_404 from django.test import TestCase from .models import Article, Author class GetObjectOr404Tests(TestCase): def test_get_object_or_404(self): a1 = Author.objects.create(name="Brave Sir Robin") a2 = Author.objects.create(name="Patsy") # No Articles yet, so we should get an Http404 error. with self.assertRaises(Http404): get_object_or_404(Article, title="Foo") article = Article.objects.create(title="Run away!") article.authors.set([a1, a2]) # get_object_or_404 can be passed a Model to query. self.assertEqual(get_object_or_404(Article, title__contains="Run"), article) # We can also use the Article manager through an Author object. self.assertEqual( get_object_or_404(a1.article_set, title__contains="Run"), article ) # No articles containing "Camelot". This should raise an Http404 error. with self.assertRaises(Http404): get_object_or_404(a1.article_set, title__contains="Camelot") # Custom managers can be used too. self.assertEqual( get_object_or_404(Article.by_a_sir, title="Run away!"), article ) # QuerySets can be used too. self.assertEqual( get_object_or_404(Article.objects.all(), title__contains="Run"), article ) # Just as when using a get() lookup, you will get an error if more than # one object is returned. with self.assertRaises(Author.MultipleObjectsReturned): get_object_or_404(Author.objects.all()) # Using an empty QuerySet raises an Http404 error. with self.assertRaises(Http404): get_object_or_404(Article.objects.none(), title__contains="Run") # get_list_or_404 can be used to get lists of objects self.assertEqual( get_list_or_404(a1.article_set, title__icontains="Run"), [article] ) # Http404 is returned if the list is empty. with self.assertRaises(Http404): get_list_or_404(a1.article_set, title__icontains="Shrubbery") # Custom managers can be used too. self.assertEqual( get_list_or_404(Article.by_a_sir, title__icontains="Run"), [article] ) # QuerySets can be used too. self.assertEqual( get_list_or_404(Article.objects.all(), title__icontains="Run"), [article] ) # Q objects. self.assertEqual( get_object_or_404( Article, Q(title__startswith="Run") | Q(title__startswith="Walk"), authors__name__contains="Brave", ), article, ) self.assertEqual( get_list_or_404( Article, Q(title__startswith="Run") | Q(title__startswith="Walk"), authors__name="Patsy", ), [article], ) def test_bad_class(self): # Given an argument klass that is not a Model, Manager, or Queryset # raises a helpful ValueError message msg = ( "First argument to get_object_or_404() must be a Model, Manager, or " "QuerySet, not 'str'." ) with self.assertRaisesMessage(ValueError, msg): get_object_or_404("Article", title__icontains="Run") class CustomClass: pass msg = ( "First argument to get_object_or_404() must be a Model, Manager, or " "QuerySet, not 'CustomClass'." ) with self.assertRaisesMessage(ValueError, msg): get_object_or_404(CustomClass, title__icontains="Run") # Works for lists too msg = ( "First argument to get_list_or_404() must be a Model, Manager, or " "QuerySet, not 'list'." ) with self.assertRaisesMessage(ValueError, msg): get_list_or_404([Article], title__icontains="Run") def test_get_object_or_404_queryset_attribute_error(self): """AttributeError raised by QuerySet.get() isn't hidden.""" with self.assertRaisesMessage(AttributeError, "AttributeErrorManager"): get_object_or_404(Article.attribute_error_objects, id=42) def test_get_list_or_404_queryset_attribute_error(self): """AttributeError raised by QuerySet.filter() isn't hidden.""" with self.assertRaisesMessage(AttributeError, "AttributeErrorManager"): get_list_or_404(Article.attribute_error_objects, title__icontains="Run")
33135e7ac73ea7ce8176f3efc7aa8bd3d95c883ef32742f5618acc819e92ea19
""" DB-API Shortcuts ``get_object_or_404()`` is a shortcut function to be used in view functions for performing a ``get()`` lookup and raising a ``Http404`` exception if a ``DoesNotExist`` exception was raised during the ``get()`` call. ``get_list_or_404()`` is a shortcut function to be used in view functions for performing a ``filter()`` lookup and raising a ``Http404`` exception if a ``DoesNotExist`` exception was raised during the ``filter()`` call. """ from django.db import models class Author(models.Model): name = models.CharField(max_length=50) class ArticleManager(models.Manager): def get_queryset(self): return super().get_queryset().filter(authors__name__icontains="sir") class AttributeErrorManager(models.Manager): def get_queryset(self): raise AttributeError("AttributeErrorManager") class Article(models.Model): authors = models.ManyToManyField(Author) title = models.CharField(max_length=50) objects = models.Manager() by_a_sir = ArticleManager() attribute_error_objects = AttributeErrorManager()
e53a31471f7d2aebff3390b2c399aec9aea32dd39294fd04393eb8c132a85f82
import datetime from django.db import models from django.test import TestCase from django.test.utils import isolate_apps from .models import InternationalArticle class SimpleTests(TestCase): def test_international(self): a = InternationalArticle.objects.create( headline="Girl wins €12.500 in lottery", pub_date=datetime.datetime(2005, 7, 28), ) self.assertEqual(str(a), "Girl wins €12.500 in lottery") @isolate_apps("str") def test_defaults(self): """ The default implementation of __str__ and __repr__ should return instances of str. """ class Default(models.Model): pass obj = Default() # Explicit call to __str__/__repr__ to make sure str()/repr() don't # coerce the returned value. self.assertIsInstance(obj.__str__(), str) self.assertIsInstance(obj.__repr__(), str) self.assertEqual(str(obj), "Default object (None)") self.assertEqual(repr(obj), "<Default: Default object (None)>") obj2 = Default(pk=100) self.assertEqual(str(obj2), "Default object (100)") self.assertEqual(repr(obj2), "<Default: Default object (100)>")